PRD-Led Context Engineering workflow
A Claude Code method: a gated PRD, 47 skills, hooks and a Markdown fact base so the agent remembers decisions between sessions.
- 179 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Hooks fire on every session start and before code writes, and the installer merges into `.claude/settings.json`. Run it with `--dry-run` first.
- Stage skills call WebSearch and WebFetch and write files into the repository.
Install
- Works in
Manual install
bash install.sh --target /path/to/your/repo --profile productSelf-install from a clone of the repository (a prototype per the README). Run with `--dry-run` first. The other path is to fork the repository and copy `README_template.md` to `README.md`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Hooks fire on every session start and before code writes, and the installer merges into `.claude/settings.json`. Run it with `--dry-run` first.
- Stage skills call WebSearch and WebFetch and write files into the repository.
This is third-party code. Review the repository files before installing.
What it does
PRD-Led Context Engineering is a repository template that takes a product from idea to growth through PRD stages v0.1 to v1.0. Decisions are written to `SoT/` files with their own IDs such as `BR-004` or `API-045`, linked into a knowledge graph. The agent loads only the IDs a task needs and the whole repository stays out of context. The `.claude/` directory holds 41 stage skills (problem framing, competitors, pricing, personas, journeys, architecture, launch), 6 `ghm-*` operator skills for gate checks and status sync, hooks and four role agents with their own memory. The `scripts/readiness.py` script scores readiness to advance to the next stage.
Who it is for. Founders and product managers building with Claude Code who are tired of re-explaining context in every session.
Good fit when
- A new product starts from zero and the agent should ask stage-by-stage questions before any app is generated.
- Business rule and API decisions are scattered across chats and need one verifiable source.
- Before moving from v0.2 to v0.3 you want to know what blocks you: the readiness script names the blocking files.
- An existing repository should adopt the method without overwriting its own files.
- A founder idea needs a fast review: `quick` mode gives a gut-check in under fifteen minutes.
Not a fit when
- The task is small and one-off: the full cycle with IDs and gates takes longer than the work itself.
- The team will not keep documentation in sync with code: the method rests on that rule.
- The agent is not Claude Code: the README treats `.claude/` as the primary layout and the hooks and agents follow Anthropic documentation.
Example request
Let us frame the product problem: start stage v0.1 and record the evidence with CFD IDs.Limitations
The method runs stage by stage, so expect no quick result on the first run. The README marks self-install into an existing repository as a prototype. The README roadmap lists a knowledge-graph MCP server and a packaged Claude Code plugin. The `.claude/` layout can be swapped for `.codex/` or `.gemini/`, but hooks and agents are written for Claude Code. IDs and gates demand discipline: a decision that does not land in `SoT/` does not exist for the agent.
How to disable. Delete the `.claude/` directory with the method hooks and skills and the `.claude/settings.json` file if the installer created it. `PRD.md`, `SoT/` and `epics/` remain as plain documentation.
FAQ
How do I start with the method?
Fork the repository for your product, copy `README_template.md` to `README.md` and open the project in Claude Code. Hooks load the read order and a phrase like "Let's frame the problem" triggers the `prd-v01-problem-framing` skill.
Can I add the method to an existing repository?
Yes, with `bash install.sh --target /path/to/your/repo --profile product`. Run it with `--dry-run` first. The installer is idempotent and merges settings into your `.claude/settings.json`.
What is SoT?
Source of Truth: `SoT/SoT.*.md` files with durable facts. Each entry gets an ID, for example `UJ-101` for a journey or `BR-004` for a business rule, and is referenced by that number.
How do I know the project is ready for the next stage?
Run `python scripts/readiness.py run`. The script scores readiness across SoT files, epics and the PRD stage and writes the result to `status/readiness.json`.
What depth modes do the skills have?
Three: `quick` for a gut-check in a quarter of an hour, `standard` by default and `deep` for an investor-ready review with an assumption log.
Discussion
No questions or reviews yet.
Related
WorkflowsA Claude Code plugin that turns a goal into a graded PRD, a dependency-ordered task graph and execution gated by evidence
A CLAUDE.md and AGENTS.md file with seven principles: the agent frames the problem and scope before it writes code
Claude Code course repository for product managers: 55 skills, slash commands, subagents and demo apps with module assignments
The prd-write skill for Codex: turns an idea, prototype and screenshots into a PRD with roles, flows, events and acceptance
A scaffold for Claude Code and Codex: tasks in files, developer and QA roles, manual approval and shared state.
A documentation-first method for Claude Code: the /interview skill, document and plan templates and handoff rules.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| PRD-Led Context Engineering (this card) | no | 179 | |
| Spec Kit | no | 149,434 | drives development from a feature specification; this one covers the whole product lifecycle from problem to growth with decision IDs |
| BMad Method | no | 55,288 | a role-agent set for agile development; here the core is a Markdown knowledge graph with a readiness score |
README in short
The author explains memory as infrastructure: four principles, a table of PRD stages and a comparison with classic Agile. The README adds human-readable SoT review pages, the repository layout and the frameworks of Dunford, Hormozi, Moore and Torres encoded into the skills.