Skip to content
Back to search

PRD-driven-context-engineering

PRD-Led Context Engineering — Memory as Infrastructure. An ontology layer for product teams building products that solve real problems — with AI agents that remember. Gated PRD, typed IDs, markdown knowledge graph, Claude Code skills & hooks.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mattgierhart--prd-driven-context-engineering/badge.svg)](/listings/mattgierhart--prd-driven-context-engineering)

HTML

<a href="/listings/mattgierhart--prd-driven-context-engineering"><img src="/api/listings/mattgierhart--prd-driven-context-engineering/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# 1. Fork this repo for your product, then:
cp README_template.md README.md     # your product dashboard replaces this page

# 2. Open the repo in Claude Code — hooks load the read order automatically.

# 3. Start the lifecycle at the beginning:
#    "Let's frame the problem"  →  triggers prd-v01-problem-framing
#    The skill produces CFD- evidence IDs and fills PRD.md v0.1.

# 4. Advance only through gates:
python scripts/readiness.py run      # are we ready for v0.2?

From there, the method drives itself: each stage's skills consume the previous stage's IDs, the readiness score tells you when to advance, and the knowledge graph grows with every decision. **No subscriptions, no servers, no lock-in — fork and go.**

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 11 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "prd-ce-methodology",
  3. "owner": { "name": "Matt Gierhart" },
  4. "plugins": [
  5. {
  6. "name": "prd-ce",
  7. "source": "./plugins/prd-ce",
  8. "description": "PRD-CE methodology engine: scaffold (PRD/SoT/EPICs) + lifecycle skills + governance hooks + readiness scoring."
  9. }
  10. ]
  11. }
README.md · README · 389 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. # PRD-Led Context Engineering
  3. ### Memory as Infrastructure — an operating system for building products with AI agents
  4. [![GitHub stars](https://img.shields.io/github/stars/mattgierhart/PRD-driven-context-engineering?style=flat&logo=github&color=a8842c)](https://github.com/mattgierhart/PRD-driven-context-engineering/stargazers)
  5. [![License: MIT](https://img.shields.io/badge/License-MIT-14120e.svg)](LICENSE)
  6. [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-3d6b35.svg)](#contributing)
  7. [![Built for Claude Code](https://img.shields.io/badge/built%20for-Claude%20Code-a8842c.svg)](.claude/)
  8. *Your AI partner is brilliant in one session and amnesiac by the next. This repository is the fix:
  9. a fork-ready methodology that turns documentation into a knowledge graph humans and AI navigate
  10. together — so the 50th session is smarter than the 1st.*
  11. [**Quick Start**](#-quick-start) · [**The Idea**](#the-idea-memory-as-infrastructure) ·
  12. [**The Lifecycle**](#-feature-the-progressive-prd) · [**The Skills**](#-feature-47-skills-one-for-every-decision) ·
  13. [**Live Demo Views**](#-feature-the-human-review-layer)
  14. <img src="temp/sot-html-mockups/atlas.png" alt="The Source-of-Truth Atlas — the knowledge graph rendered for humans" width="760">
  15. **⭐ If this changes how you build with AI, [star the repo](https://github.com/mattgierhart/PRD-driven-context-engineering/stargazers) — stars put this method in front of the next team drowning in context drift.**
  16. </div>
  17. ---
  18. <!-- SECTION: evolution -->
  19. ## The Problem: AI forgets. Teams drift.
  20. Every era of software solved memory its own way — and broke it its own way:
  21. - **Waterfall** had **Static Memory**. Write everything down upfront: certainty, at the cost of change.
  22. - **Agile** moved fast and created **Fragmented Memory**. Knowledge scattered across tickets, wikis, and chats; shared understanding evaporated.
  23. - **AI-assisted building** adds a third failure: **Amnesiac Memory**. The model that architected your system yesterday has never heard of it today.
  24. The common mistake is treating these as tooling problems. They are *memory* problems.
  25. **PRD-Led Context Engineering** builds **Shared Memory**: it treats AI as a team member, not a tool, and keeps documentation synchronized with code so humans and AI navigate the same truth.
  26. <!-- /SECTION: evolution -->
  27. ---
  28. <!-- SECTION: manifesto -->
  29. ## The Idea: Memory as Infrastructure
  30. This methodology comes from two converging experiences.
  31. **Leading human teams** — alignment always followed the same pattern: rally around a single Source-of-Truth artifact and the team moves as one. Without it, even great talent drifts.
  32. **Partnering with AI** — sometimes the model performs at a senior level, sometimes it hallucinates. The variable was never the model's intelligence. It was the **Context Density** provided: rich, structured context in; senior-level output out.
  33. The convergence: **documentation is not an afterthought. Documentation is the infrastructure of shared memory.**
  34. > **The Golden Rule**: If it isn't part of the memory infrastructure, it isn't true.
  35. So every durable decision gets a **Unique ID** (`UJ-101`, `BR-004`, `API-045`) in a **Source-of-Truth file**. That ID is a memory node with weight: when the AI references `BR-004`, it isn't guessing — it's retrieving a specific, validated decision you encoded. The linked network of IDs across files *is* the **Knowledge Graph**, and it lives in plain markdown, in your repo, under version control.
  36. ### The 4 Pillars
  37. 1. **Just-in-Time Context** — IDs let you load *only* what a task needs. No repo-dumps, no noise, fewer hallucinations.
  38. 2. **The Documentation Ecosystem** — PRD ↔ EPICs ↔ SoT connected by links, skills, and hooks. When logic changes, both human and AI know.
  39. 3. **Context Validation** — context is measured like code. Too sparse, the AI drifts; too dense, it chokes. The repo scores itself (see [Readiness Scoring](#-feature-a-repo-that-scores-its-own-readiness)).
  40. 4. **Progressive Documentation** — update in place, never copy. No `PRD_v2.md`, ever. One document, many versions, single current reality.
  41. <!-- /SECTION: manifesto -->
  42. <!-- SECTION: cognitive-shift -->
  43. ### The Cognitive Shift
  44. This changes how work is *measured*, not just how it's tooled:
  45. | Traditional Agile | PRD-Led Context Engineering | The Shift |
  46. | :--------------------- | :--------------------------------- | :----------------------------------------------------------------------------------------------------- |
  47. | **Sprints** | **Context Windows** | We don't time-box based on dates; we _scope-box_ based on cognitive capacity. |
  48. | **User Stories** | **Prompts** | We don't write descriptions; we engineer _prompts_ that deterministically load context. |
  49. | **Tribal Knowledge** | **Source of Truth** | If it isn't in the Knowledge Graph (`SoT/`), it doesn't exist. |
  50. | **Standups** | **Documentation Hooks** | No status meetings. Event-driven hooks handle context loading, gate checks, and memory handoffs. |
  51. | **Project Management** | **Context Governance** | We don't task-manage people. The system gates execution until context is verified valid. |
  52. <!-- /SECTION: cognitive-shift -->
  53. ---
  54. ## What's in the box
  55. Everything below ships in this repo, works offline, and forks in one click:
  56. | Feature | What it gives you |
  57. |---|---|
  58. | 🧠 [The Knowledge Graph](#-feature-a-knowledge-graph-in-plain-markdown) | 14 SoT files, 21 ID types, zero databases — durable memory in markdown |
  59. | 📈 [The Progressive PRD](#-feature-the-progressive-prd) | A gated v0.1 → v1.0 lifecycle that stops AI from one-shotting your architecture |
  60. | 🛠 [47 Skills](#-feature-47-skills-one-for-every-decision) | Stage playbooks from problem framing to crossing the chasm — Dunford, Hormozi, Moore, Torres built in |
  61. | 📊 [Readiness Scoring](#-feature-a-repo-that-scores-its-own-readiness) | The repo computes whether you're ready to advance — and what to fix first |
  62. | 🫀 [The Development Graph](#-feature-code-that-traces-back-to-specs) | `@implements` tags bridge code to specs; drift surfaces as a verdict, not a surprise |
  63. | 📰 [The Human Review Layer](#-feature-the-human-review-layer) | Every SoT file rendered as a styled, hyperlinked page its reviewer actually wants to read |
  64. | 🤖 [The Agent Squad](#-feature-an-agent-squad-with-persistent-memory) | Four role agents with persistent memory, coordinated through files instead of meetings |
  65. ---
  66. <!-- SECTION: doc-ecosystem -->
  67. ## 🧠 Feature: A Knowledge Graph in plain markdown
  68. **The pitch**: long-term product memory with no database, no SaaS, no lock-in — just files with discipline.
  69. The architecture is **3 + 1 + SoT + Temp**, designed to manage Context Density for both human cognitive load and AI context windows:
  70. 1. **Executive Functions** — orient attention. Files load stable→volatile to maximize prompt-cache hits:
  71. - `README.md` — the Dashboard (where am I? what is active?)
  72. - `PRD.md` — the Strategy (why and what)
  73. - `CLAUDE.md` — the Physics (how the AI must behave)
  74. 2. **Focus Memory** — `epics/`: the only variable state. An EPIC frames one problem as one context window.
  75. 3. **Long-Term Memory** — `SoT/SoT.*.md`: the immutable facts. Business Rules (`BR-`), User Journeys (`UJ-`), API Contracts (`API-`), and 18 more ID types. Nothing duplicated; everything referenced by ID.
  76. 4. **Short-Term Memory** — `temp/`: the scratch pad. Files attach to the active EPIC and get harvested to SoT before the EPIC closes.
  77. > **Just-in-Time Context**: instead of dumping documentation into the context window, reference specific IDs (`UJ-101`, `API-002`). Fewer input tokens, deeper understanding.
  78. <!-- /SECTION: doc-ecosystem -->
  79. ---
  80. <!-- SECTION: lifecycle -->
  81. ## 📈 Feature: The Progressive PRD
  82. **The pitch**: the "One-Shot" — asking AI to build the whole app at once — produces generic code and rapid drift. The Progressive PRD makes that impossible by design.
  83. `PRD.md` is a **gated workflow**, not a document. The AI focuses on one stage at a time, and no stage advances until its **Definition of Done** is met:
  84. | Version | Name | Focus | Definition of Done (DoD) |
  85. | :------- | :----------------------- | :-------------------- | :----------------------------------------------------------------- |
  86. | **v0.1** | **Spark** | Problem & Outcomes | Problem defined, Outcomes measurable, Open Questions list. |
  87. | **v0.2** | **Market Definition** | Segments & ICP | Segments sized, "Not For" defined, Business Rules (`BR-`) created. |
  88. | **v0.3** | **Commercial Model** | Value & Pricing | Competitors profiled, Pricing model, Monetization rules. |
  89. | **v0.4** | **User Journeys** | Personas & Flows | Core journeys mapped (`UJ-`), Dependencies (`API-`) noted. |
  90. | **v0.5** | **Red Team Review** | Risks & Feasibility | Risks (Market/Tech) identified, Mitigations linked to tests. |
  91. | **v0.6** | **Architecture** | Technical Strategy | Stack selected, API contracts (`API-`) drafted, `ARC-` conformance rules, Cost guardrails. |
  92. | **v0.7** | **Build Execution** | Implementation Loop | Code tested (`TEST-`), SoT updated, code traced to specs (Development Graph), Epic loop execution. |
  93. | **v0.8** | **Release & Deployment** | Operational Readiness | Runbooks (`RUN-`), Monitoring (`MON-`, `MON-DRIFT-`), Rollback plan, Changelog system, MOPS handoff. |
  94. | **v0.9** | **Launch** | Go-to-Market | Positioning (Dunford), Offer (Hormozi), Channels (ORB), Launch metrics (`KPI-`), Feedback channels (`CFD-`), Tactical playbooks (AEO, alternatives, outreach, HN/Reddit). |
  95. | **v1.0** | **Growth** | Market Adoption | Adoption stage (`ADO-STAGE-`), Beachhead (`ADO-BEACHHEAD-`), Whole product (`ADO-WHOLE-`), References (`ADO-REF-`), Continuous discovery, Case studies, Testimonials. |
  96. **Why gates work**: constrained focus prevents the AI from guessing the architecture before it understands the users; deep focus produces meaningful IDs; the result is not just a working product but a *desirable* one.
  97. **The paradox that makes it practical**: gates provide focus; the ecosystem provides agility. Because documentation is modular and interlocked, you can revisit any stage just-in-time — customer feedback during Build doesn't restart the plan, it updates the `BR-` rules and lets hooks propagate the change.
  98. <!-- /SECTION: lifecycle -->
  99. ---
  100. ## 🛠 Feature: 47 skills, one for every decision
  101. **The pitch**: the lifecycle isn't advice — it's executable. Every stage ships with skills that know what to consume, what IDs to produce, and which gate they feed.
  102. - **41 stage skills** (`prd-v01-*` → `prd-v10-*`): problem framing, competitive landscape, pricing, persona definition, journey mapping, risk discovery, architecture design, epic scoping, test planning, release planning, GTM strategy, case studies…
  103. - **6 methodology operators** (`ghm-*`): gate checks, SoT building, ID registration, insight harvesting, status sync.
  104. - **Named frameworks, encoded**: April Dunford positioning, Alex Hormozi offer construction, Owned/Rented/Borrowed channel allocation, Geoffrey Moore chasm crossing, Teresa Torres continuous discovery, Rob Fitzpatrick Mom Test interviews.
  105. - **Three depth modes** — `quick` (founder gut-check, <15 min), `standard` (default), `deep` (investor-ready, with assumption logs) — so the method scales from solo founder to team.
  106. Every skill emits `Consumes` / `Produces` sections in SoT IDs, which is what keeps the knowledge graph connected as you move through stages.
  107. ---
  108. <!-- SECTION: readiness-scoring -->
  109. ## 📊 Feature: A repo that scores its own readiness
  110. **The pitch**: before advancing a stage or starting an EPIC, the repo already knows whether you're ready — and *why not*.
  111. Readiness is a **three-layer graph** over the artifacts you already author:
  112. 1. **SoT files** — scored on entry count, depth, cross-reference density, and orphan rate. A placeholder file scores 0.
  113. 2. **EPICs** — inherit the readiness of every SoT file they reference. Dangling refs and unresolved assumptions surface as unmet criteria, each citing the file that caused it.
  114. 3. **PRD stage** — answers "can we advance v0.X → v0.Y?" from gate criteria plus the layers below.
  115. All three write to one file — `status/readiness.json` — with causal links intact: an EPIC's unmet criterion points at its `caused_by` SoT file; the top blockers are ranked by downstream impact. **The highest-leverage fix is rarely the lowest-scoring file — it's the lowest-scoring file blocking the most EPICs.** The system tells you which.
  116. ```bash
  117. python scripts/readiness.py run # compute all layers + print report
  118. python scripts/readiness.py status # print last-computed report
  119. python scripts/readiness.py run --json # machine-readable output for hooks/CI
  120. ```
  121. Exit codes `0/1/2` map to PASS / WARN / BLOCK (thresholds: warn=70, block=50, overridable per item). The `ghm-gate-check` skill delegates here for stage-advancement decisions.
  122. ### 🫀 Feature: Code that traces back to specs
  123. Once building starts (v0.7), the code itself joins the knowledge graph. An AST pass extracts code nodes into `status/devgraph.json`; the `@implements` / `@verifies` tags you write under [rule 04](.claude/rules/04-coding-standards.md) become **bridge edges** linking each code unit to the spec it realizes. Readiness then measures *reality*, not just spec health:
  124. - `implementation_coverage` — which scoped specs actually have implementing code
  125. - `architecture_conformance` — do the `ARC-` rules still hold in the as-built system (drift = a `violate` verdict, not a surprise in review)
  126. Untagged code shows up as an **orphan node** — a context leak you can see. The same `devgraph.json` powers the **HeartBeat** visualizer: a live pulse of built / unbuilt / drifted. See [`docs/DEVELOPMENT_GRAPH.md`](docs/DEVELOPMENT_GRAPH.md).
  127. **Deeper reading**: [`.claude/rules/07-readiness-protocol.md`](.claude/rules/07-readiness-protocol.md) · [`docs/READINESS_PROTOCOL.md`](docs/READINESS_PROTOCOL.md)
  128. <!-- /SECTION: readiness-scoring -->
  129. ---
  130. <!-- SECTION: sot-html-companion -->
  131. ## 📰 Feature: The Human Review Layer
  132. **The pitch**: markdown SoT files are optimized for agents and diffs. Humans reviewing a gate deserve a better reading surface — so every SoT file ships with a styled, hyperlinked HTML view in the format its natural reviewer already expects. Start at [`SoT/html/index.html`](SoT/html/index.html) (opens from `file://`, no build step, no JS).
  133. **The contract**: markdown stays authoritative; the HTML is a *render*. Entry anchors equal unique IDs (`SoT.BUSINESS_RULES.html#BR-001`), and every cross-reference is a hyperlink — a reviewer walks the knowledge graph by clicking, the same way an agent walks it by ID.
  134. | | |
  135. |---|---|
  136. | ![The Atlas — index of all SoT views](temp/sot-html-mockups/atlas.png) | ![User journey rendered as a journey map](temp/sot-html-mockups/journey-map.png) |
  137. | **The Atlas** (`index.html`) — registry of every view, ID anatomy, graph patterns | **User Journeys** — trigger → steps → value moment, the way design reviews read flows |
  138. | ![API contract rendered as an API reference](temp/sot-html-mockups/api-contract.png) | ![Data model rendered as a schema browser](temp/sot-html-mockups/data-model.png) |
  139. | **API Contracts** — Swagger-style reference with method plates and status codes | **Data Model** — ER-style entity cards with keys and a relationship map |
  140. | ![Customer feedback rendered as an insight card](temp/sot-html-mockups/feedback-card.png) | ![Adoption stage rendered as the Moore curve](temp/sot-html-mockups/adoption-curve.png) |
  141. | **Customer Feedback** — quote-first insight cards with decision stamps | **Adoption** — Moore lifecycle curve with the chasm and a "you are here" marker |
  142. Each of the 13 pages serves a different reviewer: policy register for `BR-`, ADRs + topology diagram for `TECH-`/`ARC-`, Storybook-style specimens for `DES-`, Given/When/Then cards for `TEST-`, an ops console for `DEP-`/`RUN-`/`MON-`/`SEC-`, a retro playbook for `LL-`, a vendor context map for `INT-`. The full schema-per-ID-type and persona-per-view rationale lives in [`SoT/html/README.md`](SoT/html/README.md).
  143. > **Screenshots are generated** — when the pages change, refresh them with
  144. > `python3 SoT/html/screenshot.py` (Playwright + Chromium; see
  145. > [`SoT/html/README.md`](SoT/html/README.md#refreshing-the-screenshots) for setup) and commit the
  146. > regenerated PNGs with the change.
  147. > **Next direction (concept)**: these pages render SoT *outward* for review. A proposed third artifact
  148. > class — **deliverables** — would add an *input* mode where a human contributes judgment (rank, select,
  149. > acknowledge) and the page emits paste-ready SoT markdown. See
  150. > [`docs/DELIVERABLES_CONCEPT.md`](docs/DELIVERABLES_CONCEPT.md).
  151. <!-- /SECTION: sot-html-companion -->
  152. ---
  153. <!-- SECTION: repo-structure -->
  154. ## 🤖 Feature: An agent squad with persistent memory
  155. **The pitch**: four role agents that remember, coordinate through files, and get smarter every EPIC — no standups required.
  156. - **horizon** (Strategy, v0.1–v0.5) · **studio** (Design, v0.3–v0.6) · **devlab** (Build, v0.6–v0.8) · **metro** (Ops, v0.9–v1.0)
  157. - **Memory that persists**: each agent accumulates Feedback, Patterns, Decisions, and Handoff Notes in its `MEMORY.md`. A `SubagentStop` hook actively extracts memories from the conversation. During EPIC harvest, cross-EPIC insights are promoted to `SoT/SoT.LESSONS_LEARNED.md` as durable `LL-` entries.
  158. - **Event-driven hooks instead of meetings**: `SessionStart` injects read order, `UserPromptSubmit` checks context density, `PreToolUse` verifies an active EPIC before code writes, `Stop` reminds on SoT cascade updates. Behavior is standardized by [`HOOK_CONTRACT.md`](.claude/hooks/HOOK_CONTRACT.md).
  159. - **Multi-agent EPICs without the telephone game**: a Synthesis Checkpoint forces the coordinator to produce self-contained worker prompts before implementation begins — workers never see degraded second-hand context.
  160. - **File-based standups**: the [Squad Status](#squad-status) section below shows agent activity and EPIC state at a glance, updated by `ghm-status-sync`.
  161. ### Repository structure
  162. ```text
  163. /
  164. ├── README.md # Dashboard, structure, and status
  165. ├── PRD.md # Product definition (Progressive PRD)
  166. ├── CLAUDE.md # The agent's operating instructions
  167. ├── epics/ # Active Context Windows (Tasks)
  168. ├── SoT/ # Shared Memory Store (SoT.* files + html/ review layer)
  169. ├── temp/ # Scratch Pad for explorations and audits
  170. └── .claude/ # Methodology runtime (skills, hooks, agents)
  171. ├── skills/ # 41 stage skills (prd-v*) + 6 operators (ghm-*)
  172. ├── hooks/ # Session/user/stop hooks + subagent memory hooks
  173. ├── agents/ # Role agents with persistent MEMORY.md
  174. ├── domain-profile.yaml # ID registry + skill taxonomy
  175. └── settings.json # Hook wiring and execution config
  176. ```
  177. > **Agent Note**: `.claude/` can be replaced with `.gemini/`, `.codex/`, or any other agent structure, but the skills, hooks, and agent model here were built with Anthropic's documentation model in mind.
  178. > **Fork Note**: this `README.md` explains the methodology. When you fork for a product, copy `README_template.md` to `README.md` and customize it.
  179. <!-- /SECTION: repo-structure -->
  180. ---
  181. <!-- SECTION: quick-start -->
  182. ## 🚀 Quick Start
  183. ```bash
  184. # 1. Fork this repo for your product, then:
  185. cp README_template.md README.md # your product dashboard replaces this page
  186. # 2. Open the repo in Claude Code — hooks load the read order automatically.
  187. # 3. Start the lifecycle at the beginning:
  188. # "Let's frame the problem" → triggers prd-v01-problem-framing
  189. # The skill produces CFD- evidence IDs and fills PRD.md v0.1.
  190. # 4. Advance only through gates:
  191. python scripts/readiness.py run # are we ready for v0.2?
  192. ```
  193. From there, the method drives itself: each stage's skills consume the previous stage's IDs, the readiness score tells you when to advance, and the knowledge graph grows with every decision. **No subscriptions, no servers, no lock-in — fork and go.**
  194. <!-- /SECTION: quick-start -->
  195. ---
  196. <!-- SECTION: how-to-use -->
  197. ## How to use this repo today
  198. The methodology is **fork-native**: everything runs from files in your repo, with no services to stand up.
  199. 1. **Fork it per product** — this repo is the template; each product gets its own copy with its own PRD, SoT graph, and EPICs ([Quick Start](#-quick-start) above).
  200. 2. **Or self-install into an existing repo** — run the self-install path instead of forking the whole repo (see below).
  201. 3. **Work through the gates** — let the stage skills drive: each one tells you what it consumes, what IDs it produces, and which gate it feeds. Run `python scripts/readiness.py run` before advancing.
  202. 4. **Keep the graph honest** — decisions land in `SoT/` with IDs *before or during* the change, never after. Review them as humans through [`SoT/html/`](SoT/html/index.html).
  203. 5. **Harvest every EPIC** — `temp/` notes and agent memories get promoted to durable `LL-` entries at EPIC close, so the next session starts smarter.
  204. ### Adopt into an existing repo (self-install — prototype)
  205. You don't have to fork. The **self-install path** drops the framework into a fresh *or*
  206. existing repo without clobbering product content — the subscription-native pattern
  207. borrowed from [`ZQadus/Xantham-system-blueprint`](https://github.com/ZQadus/Xantham-system-blueprint):
  208. ship a blueprint a fresh Claude Code session executes, so all cost lands on your Pro/Max
  209. plan, **not** the metered API.
  210. ```bash
  211. # Deterministic CLI (from a clone of this repo):
  212. bash install.sh --target /path/to/your/repo --profile product --dry-run # preview
  213. bash install.sh --target /path/to/your/repo --profile product # install
  214. ```
  215. Or paste the one-line bootstrap from [`BLUEPRINT.md`](BLUEPRINT.md) into a fresh Claude
  216. Code session and let the [`ghm-self-install`](.claude/skills/ghm-self-install/SKILL.md)
  217. wizard drive it. Both paths read [`.claude/install-manifest.yaml`](.claude/install-manifest.yaml)
  218. (framework vs. product file classes), are **idempotent**, and **merge** into an existing
  219. `.claude/settings.json` rather than overwriting it.
  220. ### Still on the roadmap
  221. The self-install path is the foundation — fuller distribution is next:
  222. - **MCP server** — the knowledge graph as a queryable service: look up any ID, traverse cross-references, and pull readiness scores from any MCP-capable agent, without loading files into context.
  223. - **Packaged Claude Code plugin** — the skills, hooks, and agent squad as a marketplace one-click, plus Xantham-style hardening (Docker audit sandbox, signed `CHECKSUMS.sha256`).
  224. Watch the repo to catch these when they land. The fork *and* self-install paths both work end-to-end today.
  225. <!-- /SECTION: how-to-use -->
  226. ---
  227. <!-- SECTION: squad-status -->
  228. ## Squad Status
  229. <!-- Updated by ghm-status-sync skill -->
  230. ### Agent Activity
  231. | Agent | Role | Last Active | Current EPIC | Status |
  232. |-------|------|-------------|--------------|--------|
  233. | horizon | Strategy (v0.1-v0.5) | — | — | idle |
  234. | studio | Design (v0.3-v0.6) | — | — | idle |
  235. | devlab | Build (v0.6-v0.8) | — | — | idle |
  236. | metro | Ops (v0.9-v1.0) | — | — | idle |
  237. ### EPIC Status
  238. | EPIC | State | Lead | Last Updated |
  239. |------|-------|------|--------------|
  240. | _(no active EPICs)_ | — | — | — |
  241. <!-- /SECTION: squad-status -->
  242. ---
  243. <!-- SECTION: contributing -->
  244. ## Contributing
  245. Thank you for helping refine **PRD-Led Context Engineering**. This repository is not just a codebase; it is a living system of **Memory as Infrastructure**.
  246. ### Core Philosophy
  247. Before contributing, read:
  248. 1. **[`README.md`](README.md)** — this page: the methodology and dashboard.
  249. 2. **[`CLAUDE.md`](CLAUDE.md)** — the Agent Operating Instructions.
  250. The goal is always **Context Density**: exactly the right information, at exactly the right time, for humans and AI alike.
  251. ### Ways to Contribute
  252. **Refine the methodology**
  253. - **Templates**: improve `SoT/` templates, the [HTML review layer](SoT/html/README.md), or `epics/EPIC_TEMPLATE.md`.
  254. - **Skills & workflows**: sharpen a stage skill, suggest automation hooks, or improve Source-of-Truth management.
  255. - **Documentation**: clarify the rules of the road in this README.
  256. **Report friction**
  257. - A [lifecycle gate](#-feature-the-progressive-prd) that slows you down without adding value? Tell us.
  258. - The AI struggling to find context? Report it as a **Context Leak**.
  259. ### Getting Started
  260. 1. **Fork & branch** for your feature or fix.
  261. 2. **Follow the lifecycle** — even meta-changes respect the spirit of the gated workflow.
  262. 3. **Traceability** — durable new concepts get an ID (`BR-XXX`, `UJ-XXX`).
  263. ### Contribution Standards
  264. - **Terminology**: "PRD-Led Context Engineering", "Source of Truth", and "EPICs", consistent with this README.
  265. - **Links**: relative links to files (e.g., `[Link](README.md)`), never absolute paths.
  266. - **Tone**: professional, prescriptive, rigorous.
  267. ### Questions?
  268. Open a GitHub Issue — and if the method earned it, [leave a star](https://github.com/mattgierhart/PRD-driven-context-engineering/stargazers) on the way out. ⭐
  269. <!-- /SECTION: contributing -->

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.