dify
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
- 162k
- Python
- 56 min ago

An opinionated OS for AI coding agents. Plan like a PM, execute like a senior eng. -- Claude Code plugin
Repo Yesterday-AI/ytstack, read from GitHub 1 min ago. Yesterday-AI has not joined Take My Repo.
Yesterday-AI/ytstack is a public repo on GitHub by Yesterday-AI. An opinionated OS for AI coding agents. Plan like a PM, execute like a senior eng. -- Claude Code plugin. It declares the MIT license on GitHub. It is written mainly in Shell, has 2 stars and last changed on 2026-11-17. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
An opinionated OS for AI coding agents. Plan like a PM, execute like a senior eng.
A plugin for Claude Code, Codex and Kimi Code that turns multi-session, multi-week projects into something your agent can actually hold onto. Project memory on disk, curated skill set, parallel execution via worktree-isolated subagents in Claude Code. One install, one namespace, no stack to maintain.
| 1 install |
0 separate runtimes |
40 curated skills |
MIT open source |
Open Claude Code tomorrow. The agent already knows which milestone you're in, which task is open, what the last three tasks shipped, which decisions are locked. No "remind me what we were working on" ritual. You just start.
Enterprise-capable. Equally useful for solo dev.
Open a project that uses ytstack. Before your first message, a SessionStart hook has already injected into your agent's context: (1) a directive that tells the agent to reach for ytstack skills whenever your intent matches one, (2) a state snapshot that tells it where you are, and (3) with minimal_code: on, the pointer to the work contract:
[ytstack active -- scope: project]
Project: csv-importer
Current: M002 / S01 / T04
Last updated: 2026-11-13T19:30:00Z
Working tree: /home/you/csv-importer
ytstack dir: /home/you/csv-importer/.ytstack
Next action:
Stream rows into the staging table in src/import/stage.ts
Recent tasks: T01 (added CLI flag parsing), T02 (streaming CSV reader), T03 (row validation)
Minimal-code guard is on (PREFERENCES minimal_code): smallest complete change, smallest sufficient evidence. ...
The files in .../.ytstack are the source of truth for this project's state. Read STATE.md for the full dashboard, spec/SPEC.md for what applies now, ...
From there, you just talk to the agent. You rarely type slash-commands. The agent maps your natural-language requests to the right skill:
ytstack:plan-milestone or plan-task based on where you areytstack:summarize-task, writes the outcome, flips the checkboxytstack:systematic-debugging (root-cause required, no symptom patches)ytstack:resume-session, produces a 3-paragraph briefingytstack:office-hours for forcing questionsytstack:incident: a record, every mitigation as a script you run, the cause afterwardsSlash-commands are for steering, not driving. Type /ytstack:<name> when you want to override the skill the agent would have picked, skip a step, or trigger an unusual workflow (e.g. running ytstack:plan-ceo-review on a milestone you already sliced, to challenge the premise again). For the happy path, natural language is enough.
Stepping away for a week? Say "let's do a handoff" -- agent fires ytstack:handoff-session, writes a rich handoff file. You or a teammate pick up from the file without re-explanation.
AI coding agents are excellent inside a single session and fall apart between them. Long projects rot: context-window pressure makes the agent forget early decisions by the time it reaches late ones. You re-explain architecture every morning.
Three existing tools each solve it from a different angle and overlap in the middle:
investigate for systematic debugging, qa, review, ship) and session-level context save/restore. What it lacks: explicit TDD enforcement, and a structured milestone / slice / task artifact hierarchy that survives beyond "notes from the last session."gstack and superpowers overlap heavily in scope -- both ship planning, both ship debugging -- but each has a distinctive strength the other lacks. GSD has what neither has (structured artifact memory) but ships as a runtime. Combining all three by hand produces friction: skill conflicts, redundant planning flows, 50+ skill descriptions in every system prompt.
Install all three and you get friction: interactive prompts blocking each other, skill overlap, 50+ skills flooding every system prompt, a separate runtime to maintain. See the combining articles on dev.to and Medium for the full diagnosis.
ytstack is the curation. One plugin. We cherry-pick the non-overlapping best: gstack's strategy-review skills (CEO / eng / office-hours), superpowers' discipline skills (TDD / systematic-debugging / verification). We skip the overlap: gstack's investigate duplicates superpowers' systematic-debugging, superpowers' writing-plans conflicts with our milestone / slice / task flow, etc. GSD's project-memory discipline is re-implemented natively as skills + hooks -- no separate runtime. Claude Code's native worktree subagents handle parallel execution (Agent Teams as an opt-in).
Agent-driven, not user-driven. A SessionStart hook injects a "using ytstack" directive on every session start that tells the agent to map your natural-language intent to the right ytstack skill and invoke it before responding. You talk in plain language; the agent fires skills in the background. Slash-commands (/ytstack:<name>) exist for explicit steering -- they're the escape hatch, not the normal path.
Never lose context across sessions. Every ytstack project gets a .ytstack/ directory with PROJECT.md, DECISIONS.md, KNOWLEDGE.md, STATE.md, and a milestone / slice / task hierarchy. Files are git-tracked Markdown. The same SessionStart hook injects the relevant state on every session start. The agent always knows where it is.
A technical spec that says what applies now. Plans and summaries are history; they do not describe the system. .ytstack/spec/SPEC.md is a one-page entry point, .ytstack/spec/<area>.md describes one part of the system each: behaviour, contracts, where it is implemented, how to verify a change, which decisions are in force. Where you already have an architecture document, the area file points at it instead of repeating it. The loop keeps it true: a task plan names its spec impact, a task that changed behaviour is not closed until the area file or its source says so, and bin/ytstack-spec drift lists the areas whose code moved on. A fix that restores the described behaviour, a refactoring and a typo need no spec edit. An existing ytstack project gets its spec from /ytstack:adopt-brownfield, which then touches nothing else. Format: docs/ux/spec-format.md.
A person looks at a change when its risk asks for one. Whether a finished change merges without you is decided per change. A script computes a floor from the diff: a change to a rule document, to the invariants or decisions of an area, to the checks, or to code no area covers always goes to you; dependencies, migrations and large changes are never low risk. A reviewer that is not the author states the class (low, normal, high) and names every invariant or decision the change touches, also when only code moved; touching one always goes to you. Each area of the spec says how much may merge into it without a person (auto_merge). A kind of change can require a second review: .ytstack/spec/REVIEW.md names, for example, a ui lens for the interface paths that reads your design guidelines, and its reviewer starts the product itself at the reviewed commit, operates it in a browser and takes its own screenshots (ytstack:visual-review). merge_by: risk (the default) merges only when all of that holds and the host's checks are green; you get one line per change that merged without you. A project that declares nothing behaves as before: everything goes to you. Format: docs/ux/review-policy-format.md.
The running product, the release, and production. .ytstack/RUNTIME.md can say how the product starts in a worktree, how to read which commit a target serves, and where production signals come from (docs/ux/runtime-format.md). bin/ytstack-runtime up starts the product on a port of its own per worktree, so implementers and verifiers check the running product and not only tests. After a merge bin/ytstack-watch release waits until the target serves the commit and stays healthy and prints a receipt; it deploys nothing. ytstack:signal-intake reads the signal sources (for example from a schedule), records each real finding once and notices regressions; ytstack:incident keeps the record of an outage and prepares every mitigation as a staged script that only you run. Nothing in this group changes production.
Plan like a PM, execute like a senior eng. Cherry-picked skills from gstack (CEO-review, office-hours, eng-review) lock the plan before code lands. Cherry-picked skills from superpowers (TDD, systematic-debugging, verification-before-completion) lock the code before it ships.
Parallel execution without a custom runtime. ytstack:spawn-milestone-team turns the main session into a thin orchestrator: one ytstack:implementer subagent per slice in its own git worktree (isolation: worktree, skills preloaded, fresh context), one ytstack:verifier per finished slice branch, then a merge the orchestrator owns. Claude Code Agent Teams remain an opt-in (team: on) for milestones where teammates must talk to each other. No separate CLI, no SQLite, no TUI to babysit.
One namespace, upstreams consumed the way they want to be. Skills appear as /ytstack:<name> -- no conflicts with other plugins. vendor/superpowers/ is a read-only git subtree mirror pinned to an upstream tag (v7.0.2); we never modify it, we inline it. From gstack, ytstack takes exactly six skills and ships them as its own adaptations (office-hours, plan-ceo-review, plan-eng-review, retro, ship, document-release): no gstack install, no Bun, nothing registered in ~/.claude/skills/. Each records the gstack release it follows; bin/ytstack-gstack-diff shows upstream changes before every release.
ytstack covers four workflows. The SessionStart hook injects the using-ytstack directive once per session; skill selection after that is semantic -- the agent matches user intent against each skill's description: field, not a phrase list.
.ytstack/ yetFrom raw idea to shipped task. Each process step (blue) produces an artifact on disk (green) that the next step reads as a contract.
Source: docs/ytstack-greenfield-flow.excalidraw (single source of truth).
Existing codebase, no .ytstack/ yet? That is not greenfield. A repo with its own README, docs/, CHANGELOG, ADRs and months of commits skips the pitch: say "set up ytstack here" / "adopt ytstack" and the agent fires ytstack:adopt-brownfield. The SessionStart hook already flags such a repo (>= 2 brownfield signals) and init-project routes there by itself when it finds a mature repo without a pitch. adopt-brownfield maps the existing files onto PROJECT.md / DECISIONS.md / KNOWLEDGE.md / RUNTIME.md by reference (your docs stay the source of truth), asks per file how to handle it (reference / extract / move / leave), writes a codebase map (.ytstack/codebase/{stack,architecture,conventions,concerns}.md) from four read-only subagents, and scaffolds only the gaps (STATE.md with a tracker: field for Linear / GitHub Projects / Paperclip / Jira). The shipped track record is the validation; office-hours is reserved for genuinely new scope.
.ytstack/, continuing or starting new workSessionStart hook injects STATE.md + the using-ytstack directive before your first message. Natural-language routing:
<session start: state injected>
-> "where were we" -> ytstack:resume-session (3-paragraph briefing)
-> "let's plan what's next" -> ytstack:plan-milestone (if no active milestone)
ytstack:plan-task (if milestone is active)
-> "this task is done" -> ytstack:summarize-task (close + flip checkbox)
-> "review my changes" -> ytstack:code-review (reviewer subagent on the task's commits)
-> "let's do a handoff" -> ytstack:handoff-session (rich HANDOFF.md)
-> "poke holes in this idea" -> ytstack:grill (question it before plan-milestone)
-> "finish the branch" -> ytstack:finish-branch (merge / PR / keep, after the slice is closed)
-> "ship it" -> ytstack:ship (release flow: tests, review, PR)
-> "retro" -> ytstack:retro (after the milestone closed)
-> "write the changelog" -> ytstack:document-release (release notes from the summaries)
-> "check the UI of this" -> ytstack:visual-review (product started at the commit, own screenshots)
-> "what did the bots catch" -> ytstack:review-lessons (escapes of the own reviewers, a proposed line)
-> "what does prod report" -> ytstack:signal-intake (findings under .ytstack/signals/, read only)
-> "production is down" -> ytstack:incident (record, mitigations you run, cause afterwards)
-> "learn from this" -> ytstack:lesson (class, a check first, recorded; repeats count)
Continuing an open task:
plan-task -> test-driven-development -> verification-before-completion -> code-review -> summarize-task
After the last task of a slice: reassess-roadmap, then finish-branch or ship. After the last slice of a milestone: retro, document-release, plan-milestone. The SessionStart hook prints these as hints when it sees a closed slice or milestone.
At each slice boundary: ytstack:reassess-roadmap to check the plan still fits reality.
Parallel variant: ytstack:spawn-milestone-team dispatches one worktree-isolated implementer subagent per slice (branch ytstack/M###-S##), verifies each slice branch with a fresh verifier subagent and merges what passed. PREFERENCES team: on (plus CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) switches to Claude Code Agent Teams instead.
"something's broken, find it" -> ytstack:systematic-debugging
Phase 1: root-cause investigation (no fixes yet)
Phase 2: pattern analysis
Phase 3: hypothesis testing
Phase 4: implementation
Production is down right now? That is ytstack:incident first: the mitigation comes before the cause. It collects what is seen with read times, proposes mitigations as staged scripts you run, and hands the root cause to systematic-debugging afterwards. What production reports between incidents comes in through ytstack:signal-intake as findings under .ytstack/signals/.
Iron rule: root cause required before any fix. Findings auto-log to KNOWLEDGE.md (pattern) and DECISIONS.md (architectural shift).
Fix path merges back into the brownfield task loop: regression test first (test-driven-development) -> verification-before-completion -> summarize-task. Same task skeleton as feature work, not a separate "debug mode".
A finished change does not merge because it is finished. A reviewer that is not the author states its class and the invariants it touches; the lenses that REVIEW.md requires for that kind of change run, a ui lens through visual-review at the running product. bin/ytstack-risk route then puts the floor from the diff, the stated class and the ceiling of the touched areas together: with merge_by: risk the change merges without you only when every condition holds and the host's checks are green; everything else comes to you. After the merge bin/ytstack-watch release waits until the target serves the commit and stays healthy. A release that does not arrive or is unhealthy goes to you at once; an outage is incident, and what production reports between incidents comes in through signal-intake. Both lead back into the plan. A project with review roles of its own (## Own reviewers in REVIEW.md) also learns from each merge: review-lessons records the review-bot findings those roles missed, and a repeated or severe one becomes a proposed line for the role's file that you approve.
| Need | gstack alone | superpowers alone | GSD alone | ytstack |
|---|---|---|---|---|
| CEO / founder-mode strategy review | ✅ | -- | -- | ✅ (via wrapper) |
| YC-office-hours forcing diagnostics | ✅ | -- | -- | ✅ (via wrapper) |
| Engineering plan / architecture review | ✅ | partial (brainstorming) | -- | ✅ (via wrapper) |
| TDD as enforced discipline | -- | ✅ | -- | ✅ (via wrapper) |
| Systematic debugging with root-cause gate | ✅ (investigate) |
✅ | -- | ✅ (superpowers wrapper) |
| Verification-before-completion gate | partial (via ship) |
✅ | ✅ | ✅ (via wrapper) |
| Structured milestone / slice / task artifacts | -- | -- | ✅ | ✅ (native) |
| Cross-session project memory | light (context-save) |
-- | ✅ | ✅ (native) |
| Parallel fresh-context work (worktree subagents; Agent Teams opt-in) | -- | -- | via subprocess | ✅ (native) |
| SessionStart-hook state injection | -- | ✅ (for its own skills) | -- | ✅ (for project state) |
| No separate runtime to install | ✅ | ✅ | ❌ | ✅ |
| One namespace, one install | plugin-level | plugin-level | n/a | ✅ |
| Skill conflicts when combined with others | medium | medium | n/a | none |
gh (for ship, document-release, and the pull request steps of finish-lane and bin/ytstack-watch; GitHub is the only pull request host they support). jq or Python 3 for the hooks' JSON handling; Python 3 for bin/ytstack-check.visual-review: a browser tool in the session that renders a page and returns a screenshot (a Playwright-style browser server or command line, or the host's built-in browser). Without one a visual lens records not run.office-hours, plan-ceo-review, plan-eng-review, retro, ship, document-release) ship inside the plugin, so gstack and Bun are not needed and nothing is registered in ~/.claude/skills/.codex plugin marketplace add Yesterday-AI/ytstack codex plugin add ytstack@ytstack
Start a new session. With trusted hooks, ytstack supplies its runtime context
automatically. Without hooks, first ask Codex to read the installed plugin's
codex/adapter.md, then select $ytstack:using-ytstack in the skill picker.
On local hosts with hook support, review and trust the plugin hooks for automatic
startup context, compaction handoff, and session journaling. All supported hosts load the same 40 skill files. Worktree subagents, Claude Agent Teams and edit/commit hooks remain
Claude-only; Codex and Kimi use the sequential task flow and explicit verification.
See Codex setup and compatibility for local development,
hook-free usage, and validation.
Install a reviewed local checkout from Kimi's plugin manager, then reload:
/plugins install /absolute/path/to/ytstack
/plugins reload
Use /new for a fresh session and /plugins info ytstack to check 40 skills and
five lifecycle hooks. Invoke skills as /skill:ytstack:<name>. Kimi combines the
static sessionStart skill with pending context consumed once through
UserPromptSubmit; SessionStart hook stdout is not a context channel.
See Kimi setup and compatibility for updates, adapted gstack
skills, interactive close, headless limits and the tested version matrix.
The installation methods below are for Claude Code.
claude --plugin-dir /path/to/ytstack
Starts a fresh Claude Code session with ytstack loaded. Skills appear as /ytstack:<skill-name>. No marketplace registration needed. Reload after edits with /reload-plugins.
ytstack ships in Yesterday's public plugin catalog, yesterday-public-plugins (repo Yesterday-AI/skills), which imports ytstack from its own repo.
/plugin marketplace add Yesterday-AI/skills /plugin install ytstack@yesterday-public-plugins
ytstack declares no plugin dependencies (DECISIONS 2026-11-07 "No hard plugin dependencies"): web-design from the same catalog is recommended for frontend work and installs separately with /plugin install web-design@yesterday-public-plugins.
ytstack also self-marketplaces from its own repo, useful when you want to pin directly to it:
/plugin marketplace add Yesterday-AI/ytstack /plugin install ytstack@ytstack
See .ytstack/DECISIONS.md for the marketplace history.
claude --plugin-dir /path/to/ytstack --permission-mode acceptEdits -p "<prompt>"Without --permission-mode acceptEdits, Write operations stall on permission dialogs. The Agent Teams opt-in (team: on) additionally requires CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. See .ytstack/KNOWLEDGE.md for the full gotcha list.
You talk in natural language; the agent fires skills automatically. Slash-commands exist as an override path when you want to skip a step or re-run one. For the happy path you never type them.
Greenfield (empty project dir, no .ytstack/ yet). Say something like "baue mir eine cli die X macht" / "let's build a tool that Y" / "I have an idea for Z". The agent matches your intent against each skill's description: semantically and walks the chain:
| You say / what happens | Agent fires | Artifact produced |
|---|---|---|
| "build me X" / "I have an idea for Z" | ytstack:office-hours |
OFFICE-HOURS.md (pitch with name: + one-liner: frontmatter) |
| (after pitch is written) | ytstack:plan-ceo-review (concept mode) |
annotation block prepended to pitch |
| (optional, if architecture needs sanity-check) | ytstack:plan-eng-review (concept mode) |
annotation block prepended to pitch |
| (once pitch is locked) | ytstack:init-project |
.ytstack/ with 6 core files, PROJECT.md populated from pitch frontmatter, spec/SPEC.md plus one planned file per area |
| (after scaffolding) | ytstack:plan-milestone |
M001-CONTEXT.md + M001-ROADMAP.md |
| "break this into slices" | ytstack:slice-milestone |
M001-S##-PLAN.md per slice |
| (per task in the slice) | plan-task -> TDD -> verify -> summarize-task |
T##-PLAN.md -> code + tests -> T##-SUMMARY.md |
Existing codebase (README, docs/, commits, but no .ytstack/ yet). Say "adopt ytstack here" / "set up ytstack for this project" -> ytstack:adopt-brownfield links your docs into .ytstack/, maps the codebase, and scaffolds only what is missing. No pitch. Then "plan the next milestone" -> plan-milestone scopes the delta.
Brownfield (ytstack already initialized). Say what you want in plain language:
resume-session produces a 3-paragraph briefingplan-milestone (no active milestone) or plan-task (active milestone)summarize-task closes the task, flips the checkbox, updates STATE.mdsystematic-debugging runs its 4-phase root-cause procedure (no symptom patches)handoff-session writes HANDOFF.md for the next sessionquick-task ships it through the quick lane (.ytstack/quick/Q###-*), no milestone bookkeepingreconcile lists leftovers and asks per class; archives, never deletesType /ytstack:<skill-name> only when you want to override the auto-pick, skip a step, or explicitly re-run one (e.g. /ytstack:plan-ceo-review to re-challenge a milestone you already sliced). The using-ytstack directive loaded at session start enforces this model via the Skill tool.
See QUICKSTART.md for the end-to-end worked example written in the same natural-language style. Setting up risk routing, the PR watch, the release watch, signals and the upkeep run: Setting up the factory tools. After claude plugin update ytstack: Upgrading from 0.x.
ytstack's milestone / slice / task loop is the default, not a mandate. These keys in .ytstack/PREFERENCES.md (written by init-project, read by every lifecycle skill) size the ceremony to the project (DECISIONS 2026-11-07 "Ceremony scales with the change"):
| Key | Values (default first) | Effect |
|---|---|---|
granularity |
task, slice, milestone |
smallest unit that gets a PLAN/SUMMARY pair; slice collapses T## files into M###-S##-*.md, milestone into M###-*.md |
autonomy |
loop, step |
loop chains plan-task -> TDD -> verify -> summarize inside a slice without asking (stops at slice boundaries and HARD-GATEs); step returns control after each skill |
quick_lane |
on, off |
one-sentence changes ("rename X", "bump Y", "fix the off-by-one in Z") go through ytstack:quick-task: a Q###-PLAN/SUMMARY pair under .ytstack/quick/, TDD + verification, no pitch, no review, no pointer change |
minimal_code |
on, off |
the SessionStart hook injects the pointer to ytstack:minimal-code, the work contract: smallest complete change (reach before size, six-rung YAGNI ladder, never-cut list, shortcut: markers) and smallest sufficient evidence (run what the plan names, as often as it says) |
upstream_feedback |
suggest, file, off |
what concerns ytstack itself: suggest drafts an issue and asks you; file searches, then files or comments at Yesterday-AI/ytstack (public, so opt-in); off sends nothing. Falls back to upstream_feedback= in ~/.ytstack/config |
merge_by |
risk, human, coordinator |
who merges a finished lane: risk lets the coordinator merge when bin/ytstack-risk route says unattended and the host's gates hold, otherwise you; human always you; coordinator always the coordinator. A value outside the three reads as human |
evidence_dir |
a path, default .ytstack/evidence |
where a visual review stores its screenshots and their MANIFEST |
escalate |
a list of violation, deviation, irreversible, secret, spend (default all five) |
what a coordinator brings to you: a rule or concept violation, a plan deviation, an irreversible or production step no plan line covers, a secret, spend. Everything else that no plan line (verdict, approval, sign-off) or standing instruction reserves, it decides and records in DECISIONS.md. An item outside the five reads as all five |
Work is bounded like code. The same contract limits checking, reviewing and orchestrating, and it reaches every worker: bin/ytstack-brief render builds the brief for a dispatched agent (a Claude subagent or codex exec) from the plan files and includes the contract verbatim, and bin/ytstack-brief check validates the worker's report, which has fixed labels (a status, the checks with their exit codes, "Not checked:", the next action). A plan's Verification section names the command, how often it runs and where; execution does not add passes. A review has rounds: the first is complete, the second covers the fix, a third becomes a diagnosis of scope, conflicting rules or solution. A reviewer states the load it assumed and gives a concrete case for every finding; the project's own severity policy decides what blocks. Evidence is a check on a commit in an environment and does not expire because a new session reads it. What only a person can decide is written as a gate (who decides, how, when it lapses); reassess-roadmap brings all open gates in one question and reports two numbers, closed by work and accepted.
Milestone states are data, not prose: planned, in-progress, done, dropped, shipped-informally (reassess-roadmap asks about stale milestones every 14 days). Leftovers (draft stubs, unfilled auto-drafts, planned-never-sliced milestones, untracked .ytstack files) are handled only by ytstack:reconcile, which asks per class and archives into .ytstack/archive/<date>/ -- .ytstack/ artifacts are user-owned and no agent deletes them on its own. The SessionStart hook also lints the STATE pointer (malformed fields, pointer behind the newest milestone, task already summarized, stale last_updated) and plan-task / summarize-task refuse a malformed pointer. Reading tolerates the layouts consumers already use (milestones/M###/, decisions/, backlog/{,shipped,rejected}/, quick/); writing stays flat.
Coordinating many lanes. A session that owns a plan with dozens of packages and delegates all of it keeps its state in files, so that it can lose its context and continue (ytstack:coordinate; formats in docs/ux/coordinator-format.md):
| File or tool | What it is for |
|---|---|
the lanes file (out of tree per repository; .ytstack/LANES.md only as a snapshot), bin/ytstack-frontier |
one row per delegated lane; slice plans name what blocks them; the frontier is what is open, unblocked and unclaimed; a claim precedes every dispatch, so no lane starts twice |
bin/ytstack-plans |
a plan kept outside .ytstack/ (plans/*.md tables or checklists) is invisible to the frontier; scan finds one with at least 10 open rows, and ytstack:reconcile (or adopt-brownfield) asks once whether to map its open rows into milestones and slices, each with a pointer back to its row. The plan files are never written (docs/ux/external-plans.md) |
bin/ytstack-finish-lane, ytstack:finish-lane |
a reported lane becomes a merged pull request: commit what it left, push, wait until the host shows the head, review pinned to that commit, the required lenses, the route, gates read from the host, merge at the reviewed commit, then the release watch (GitHub through gh; who merges is merge_by) |
bin/ytstack-risk |
whether a change may merge without a person: floor from the diff, route from the review records, the ceilings of the touched areas and the lenses, check for REVIEW.md, manifest for the screenshots of a visual review |
bin/ytstack-review-escapes |
for a project with review agents of its own ("Own reviewers" in REVIEW.md): which findings a review bot made on a pull request were fixed and which own role reported them first; a fixed finding no role caught is an escape (exit 10). Read-only through gh |
ytstack:visual-review |
the lens reviewer of a user interface change: starts the product at the reviewed commit, operates it in a browser, its own screenshots against your guidelines; not run when it cannot, never a pass |
ytstack:handover-step, bin/ytstack-handover |
a step only you may perform arrives as one staged script with read-only checks, a confirmation before every change and a receipt; the agent checks it and never runs it |
.ytstack/questions/, bin/ytstack-questions |
one file per question for you, asked once, decision-ready |
.ytstack/standing/, bin/ytstack-check --standing |
what you asked for once and for all, written down when you say it: one file per instruction, a newer one supersedes an older one by name; .ytstack/STANDING.md alone stays valid |
bin/ytstack-watch |
polls pull requests outside the model and prints a line only when something changed; release --commit <sha> follows a merged commit until the target serves it and stays healthy, and prints one receipt |
ytstack:lane-retro |
samples finished lanes; a mechanical mistake becomes a check that replaces an instruction line |
bin/ytstack-upkeep |
one read-only run over .ytstack/ that lists what needs a look (spec, STATE, gates, questions, lanes, runtime, review policy); --question leaves one question file. On a schedule: docs/recipes/recurring-upkeep.md |
A status never states a pull request's state from memory: host facts are read fresh and carry their read time. How to switch these tools on, step by step with a check each: QUICKSTART, "Setting up the factory tools".
What has run where: the suites use a stand-in for gh and fixture targets. Against a real host, bin/ytstack-review-escapes has read 30 merged pull requests of one repository (read-only, M030). No eval or session has yet merged a change without a person, and none has run ytstack-watch release against a real target. The nearest field case: on 2026-11-14 a coordinator on a large repository dispatched two production releases and did the post-check of each by hand (issue #54), the steps a "Release" section and ytstack-watch release are meant to take over.
Two kinds of state, two places (since 0.2.0; DECISIONS 2026-11-07):
| Kind | Where | Written by | In git? |
|---|---|---|---|
Project memory: PROJECT.md, DECISIONS.md, KNOWLEDGE.md, STATE.md, ROADMAP.md, the technical spec under spec/, plans, summaries, the hand-written HANDOFF.md |
.ytstack/ in the checkout |
you and the skills (summarize-task, handoff-session, ...) on purpose |
yes |
Volatile session state: automatic pre-compaction handoff (HANDOFF.auto.md), session journal (session.jsonl) |
${CLAUDE_PLUGIN_DATA}/repos/<repo-key>/worktrees/<worktree-key>/sessions/<session_id>/ with a latest-handoff symlink per worktree (fallback .ytstack/.local/, gitignored by init-project) |
the pre-compact and session-end hooks |
no |
Every hook and skill preamble resolves the checkout from where the agent actually works (the hook payload's cwd, via hooks/lib/git-ctx.sh), never from CLAUDE_PROJECT_DIR, which Claude Code pins to the session-start directory and does not move into a linked worktree. Consequences you can rely on: a session that works in a worktree never dirties the shared main checkout; HANDOFF.md is never overwritten by a hook; the draft T##-SUMMARY.md stub appears only in the checkout that committed and only when the commit subject carries the task ref (commit_ref_pattern in PREFERENCES.md, default ^M###-S##-T##:); resume-session reads the automatic handoff first and the manual one second and tells you which it used. tests/run-all.sh (also --linux) proves all of this.
Good fit:
Poor fit:
v0.12.0 -- shipping, actively dogfooded. 0.12.0 keeps a coordinator on its operating path: standing instructions are recorded under load (bin/ytstack-standing) and reach every context, a person gets only what escalate: lists, a pull request that stalls is named with its owner's liveness (STALL 1/STALL 2, focus PRs), stale lanes and a checkout behind origin are named, briefs carry a spec delta that finish-lane checks before a merge without you, reconcile gives unplanned tasks plan skeletons, progress is reported per phase, the PR watch stays on your own pull requests, and new artifacts follow the directory their milestone lives in. 0.11.0 makes the factory tools explicit: coordinate runs the risk route, PR watch, release watch, signals and review lessons as one step and rotates in one step; the risk route reads the review round from the pull request; a session hears which tool is off and when the plugin changed under it; QUICKSTART has a setup guide; plans outside .ytstack/ can be mapped. Every incident now ends with a lesson (ytstack:lesson, a check first), and feedback about ytstack itself has a channel (upstream_feedback). 0.10.0 keeps standing instructions as one file each in .ytstack/standing/, so parallel pull requests stop conflicting over them, and keeps the PR watch readable under load: skipped jobs no longer count as work, a push of your own shows head moved until the next read, the status block appears only when it changed, and review-lessons is suggested only after a review-bot finding. 0.9.2 makes PR watch notices reach a Claude Code session that registered with its id but without the claude: prefix, and moves its stuck watches back on the next register. 0.9.1 lets a coordinating session register every open pull request of a repository that no other session watches yet (ytstack-pr-watch register --all-open), including those opened while it ran without the PR watch hooks; PRs another session owns are skipped and named. 0.9.0 adds Kimi Code host support (#49) and review lessons: a project's own review roles learn from the review-bot findings they missed (ytstack:review-lessons, bin/ytstack-review-escapes). 0.8.2 makes the PR watch worker skip a gh shim from asdf or mise for a standalone gh later on PATH, and refuse with a clear message when only a shim exists (launchd cannot run shims). 0.8.1 makes the PR watch cheap on a migrated state with many closed PRs. 0.8.0 adds the optional PR watch (bin/ytstack-pr-watch, docs/pr-watch.md): agents hear about red CI, unresolved bot threads and merge conflicts without polling, and the worker leaves a reserve of the GitHub API quota to them. 0.7.0 added the technical spec (.ytstack/spec/, #36), bounded work (#35), coordinator mode (#34), the risk gate (whether a person looks at a change is decided per change, with a visual review for interface changes), the product per worktree, the release watch, signal intake and incidents. Coordinator mode, the risk route and the release watch have run only against a stand-in for gh and fixture targets so far. 0.6.0 shipped the six gstack-derived skills as ytstack's own adaptations (no gstack install, nothing in ~/.claude/skills/) and added the upstream sync check bin/ytstack-gstack-diff. 0.5.0 added the status line segment (bin/ytstack-status, #31). 0.2.0 made hooks and skills worktree-safe and moved volatile session state out of the repository (issues #24, #26, #27); 0.3.0 pulled superpowers to v7.0.2 and turned gstack into an installed, tag-pinned dependency (#25); 0.4.0 added brownfield import (adopt-brownfield, #18), ceremony scaling (quick lane, reconcile, minimal-code guard, STATE lint), the 2026 skill bar (metadata: frontmatter, trigger-only descriptions measured by evals/, CI), six lifecycle skills (code-review, finish-branch, grill, retro, ship, document-release) and the worktree-subagent execution model. ytstack tracks its own development in .ytstack/; see .ytstack/ROADMAP.md for what is next.
Ships:
init-project, adopt-brownfield, plan-milestone, slice-milestone, plan-task, summarize-task, reassess-roadmap, quick-task, reconcile), continuity (resume-session, handoff-session), six adapted from gstack and synced with upstream (office-hours, plan-ceo-review, plan-eng-review, retro, ship, document-release), superpowers wrappers over the vendored subtree (test-driven-development, systematic-debugging, verification-before-completion, code-review, finish-branch, grill), orchestration (spawn-milestone-team, coordinate, finish-lane, handover-step, lane-retro), review and production (visual-review, review-lessons, signal-intake, incident, lesson), two directives (using-ytstack, minimal-code) and 5 engineering-OS references (atomic-design, deutschland-stack-api, european-alternatives-api, oss-project, software-craftsmanship).hooks/lib/git-ctx.sh); SessionStart injects the using-ytstack directive + project state + handoff pointers + STATE lint + lifecycle hints.bin/ytstack-status): project progress from an optional progress block in STATE.md, or the active slice's task count, plus the current task. See docs/statusline.md.bin/ytstack-pr-watch, off until enable): tells the session that opened a pull request about red CI, unresolved bot review threads and merge conflicts, through hooks for Claude Code and Codex and a 60-second background worker. See docs/pr-watch.md.tests/run-all.sh, macOS bash 3.2 + Linux bash 5), bin/ytstack-check (UX contracts, metadata: + description contract, resolver contract, vendor leaks, the repository's own technical spec) and an eval suite for claude plugin eval (evals/, 25 cases).AGENTS.md, CONTRIBUTING.md, QUICKSTART.md, UX contracts, references, methodology)yesterday-public-plugins catalogSee .ytstack/ROADMAP.md for the task list, .ytstack/STATE.md for progress, .ytstack/REVIEW-NOTES.md for deferred items.
ytstack/
├── .claude-plugin/ Claude Code plugin manifest + marketplace
├── .kimi-plugin/ native Kimi plugin manifest
├── .ytstack/ dogfood: ytstack tracks itself
├── hooks/ 9 hook scripts + pr-watch (opt-in) + hooks.json + lib/git-ctx.sh (shared resolver)
├── kimi/ Kimi runtime adapter
├── tools/pr-watch/ PR watch engine (Python 3.9+, stdlib only), driven by bin/ytstack-pr-watch
├── skills/ 40 skill packages shared by all hosts
├── bin/ ytstack-check (contracts), ytstack-spec (technical spec: lint, drift, impact), ytstack-brief (brief for a dispatched worker, report check), ytstack-frontier (lanes, claims, what may start), ytstack-plans (a plan outside .ytstack/ the frontier cannot see), ytstack-finish-lane (a lane to a merged pull request), ytstack-risk (whether a change merges without a person), ytstack-review-escapes (review-bot findings the own reviewers missed), ytstack-runtime (the product per worktree, RUNTIME.md), ytstack-handover (staged script for a human-only step), ytstack-questions (questions for the human), ytstack-watch (pull request changes, release watch), ytstack-upkeep (what needs a look, for a schedule), ytstack-signals (production findings, incident records), ytstack-gstack-diff (upstream changes of the adapted gstack skills), ytstack-status (status line segment), ytstack-pr-watch (opt-in PR watch), ytstack-codex, ytstack-kimi, dev-reinstall
├── tests/ 27 shell test suites + run-all.sh (--linux via Docker), pr_watch/ (unittest), Kimi unittest suites
├── vendor/ read-only subtree: superpowers v7.0.2 (the six gstack skills are adapted under skills/, not vendored)
├── docs/
│ ├── ux/ mandatory skill-authoring contracts and artifact formats
│ ├── recipes/ recurring-upkeep.md: the upkeep run on a schedule, per host
│ ├── research/ dated research notes
│ ├── references.md research sources
│ └── methodology.md what we adapted, from where, how
├── AGENTS.md contributor guide (for agents; CLAUDE.md symlinks to it)
├── CONTRIBUTING.md contributor guide (for humans)
├── QUICKSTART.md worked example
├── README.md this file
├── LICENSE, NOTICE MIT + attributions
└── .gitignore
PROJECT.md, STATE.md) always loaded. Task-context and background context on-demand.description: field. Phrase-lists, trigger-maps, and secret-word tables are brittle by construction -- every new phrasing (language, paraphrase, dialect) breaks them. Skills self-identify through rich when-to-use descriptions; the agent selects semantically. If selection misbehaves, sharpen the description, never add a keyword list.| Document | Purpose |
|---|---|
| QUICKSTART.md | End-to-end worked example |
| AGENTS.md | Contributor guide for AI coding agents (CLAUDE.md symlinks to it) |
| CONTRIBUTING.md | Contributor guide for humans |
| docs/concept.md | Condensed reference paper -- what ytstack wraps, skips, adds |
| docs/kimi.md | Native Kimi installation, lifecycle, gstack and support limits |
| docs/methodology.md | What we adapted from gstack / superpowers / GSD, and how |
| docs/references.md | Sources consulted while designing ytstack |
| docs/ux/ | Skill-authoring UX contracts (frontmatter, format, writing style) |
| .ytstack/DECISIONS.md | Append-only architectural decision log |
| .ytstack/KNOWLEDGE.md | Patterns + gotchas learned while building ytstack |
| .ytstack/ROADMAP.md | Milestone plan |
| .ytstack/STATE.md | Current status dashboard |
Found a bug, hit a rough edge, or want a skill that does not exist yet? Open an issue at Yesterday-AI/ytstack/issues. Agents do this for you per upstream_feedback (docs/ux/upstream-feedback.md).
Read AGENTS.md before modifying anything. See CONTRIBUTING.md for PR rules and docs/ux/ for the mandatory skill-authoring contracts.
Key rules:
vendor/** (the superpowers subtree -- wrap, don't edit)See docs/references.md for the full list of sources consulted while designing ytstack.
Three layers, cheapest first:
bin/ytstack-check -- static contracts (frontmatter, metadata:, description budget and trigger-only phrasing, resolver rules, vendor leaks). Free, runs in CI.bash tests/run-all.sh -- the shell suites in tests/ (hooks, lib, preambles, checker, and one suite per script under bin/) on macOS bash 3.2 and Linux (--linux via Docker; before a release also ubuntu:26.04 and plain alpine, see CONTRIBUTING.md). Free, runs in CI on ubuntu and macOS (.github/workflows/ci.yml).claude plugin eval . --trust-plugin --scaffold --allow-tools Write Edit Bash --ablation none --no-publish --max-cost-usd 10 -- behavioural evals in evals/: one case per lifecycle skill plus cases for rules that span skills, each a user-phrased prompt plus a skill-fired grader and an outcome grader on the produced artifact. Real model calls on your account (about $0.30 per case); not in CI, run for new and changed skills before a release. The last recorded run is in .ytstack/KNOWLEDGE.md./skill-doctor in a session and claude plugin details ytstack show what the skill listing costs and which skills never fire.
MIT. See LICENSE. Attributions in NOTICE.
Inspired by gstack, superpowers, and GSD. Built on Claude Code.
Maintained by Yesterday.
Yesterday-AI/ytstack is a public repo on GitHub by Yesterday-AI. An opinionated OS for AI coding agents. Plan like a PM, execute like a senior eng. -- Claude Code plugin.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-17. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Reverse engineer anything with agents, from app behavior down to native binaries.
Makes your AI agent think like the laziest senior dev in the room. The best code is the code you never wrote.
An open-source long-horizon SuperAgent harness that researches, codes, and creates. With the help of sandboxes, memories, tools, skill, subagents and message gateway, it handles different levels of tasks that could take minutes to hours.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/Yesterday-AI/ytstackTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.