Diff v1 → v2

  # Agentic Engineering
  
  **Building fast _and_ reliable software with AI.**
  
- Source: TBA: a fork of [github/spec-kit](https://github.com/github/spec-kit) with a compounding layer: retrospectives feed a constitution and a skills library, review gates catch silent failures, model routing keeps cost sane.
+ Source: [joexbayer/spec-kit-agentic](https://github.com/joexbayer/spec-kit-agentic) — [github/spec-kit](https://github.com/github/spec-kit) plus a compounding layer: retrospectives feed a constitution and a skills library, review gates catch silent failures, model routing keeps cost sane.
  
+ It ships as two installable components rather than a divergent fork, so upstream releases stay easy to take: an **extension** (`agentic`) that adds gates around the core pipeline, and a **preset** (`agentic`) that replaces `plan`, `tasks`, and `implement` with routing- and context-aware versions. See [[Installing and Running the Toolkit]].
+ 
  ## Why this exists
  
  Most AI-coding demos optimise for one variable: speed. "100×!" The footnote is "and you'll spend the rest of the week debugging it."
  
  > "I'm super quick at math."
  
  > "What's 5313 + 63232?"
  
  > "19."
  
  > "That's wrong."
  
  > "Yes — but it was fast."
  
  AI can produce code faster than any human. Code also has to be correct. Speed without correctness is theatre.
  
  ## The recurring failures
  
  - **The Illusion of Speed** — fast output, fast bugs. See [[The Illusion of Speed]].
  - **The One-Shot Problem** — task too big for one prompt, attempted in one anyway. See [[The One-Shot Problem]].
  - **Losing Control** — drift, hallucination, silent scope creep. See [[Losing Control: When the Agent Goes Off-Plan]].
  
  Same root cause: **too big tasks, too little context.**
  
  ## The philosophy
  
  You don't pair with the agent. You direct it.
  
  ```mermaid
  flowchart LR
      U[User] --> A[Manager / Architect]
      A --> S[Spec → Clarify → Plan → Tasks]
      S -->|dispatch| W1[Worker]
      S -->|dispatch| W2[Worker]
      S -->|dispatch| W3[Worker]
      W1 & W2 & W3 --> V[Verify]
      V --> R[Retrospective]
      R -.->|feeds| A
  ```
  
  Talk to the manager. The manager talks to focused workers, each with its own model tier and pre-fetched context. Each phase compounds.
  
  Deliberately waterfall — small steps are the only way around the one-shot problem.
  
  Underneath the whole flow sits the **constitution** — the bedrock. Enforced rules the manager respects when planning, the verifier checks against, and the retrospective amends when a failure mode hits the recurrence threshold. Every run inherits it; every run can change it. The constitution is how the system stays _yours_ — your conventions, your taste, your past lessons — instead of locking you into someone else's opinions. See [[The Compounding Layer]].
  
  ## What this isn't
  
  It's not skill-driven development. You aren't locked into someone else's prebuilt skills, opinions, or "the right way" to build. The system gives you orchestration; the steering stays yours. Your conventions, your architecture, your taste — they ride along through the spec, the plan, the constitution, the skills _you_ extract. Other workflows hand you a recipe; this one hands you a method.
  
  ## The trade
  
  You spend more time up front on planning and review.
  You spend much less time debugging code that was confidently wrong.
  
  The thing this is built to avoid: an agent runs for ten minutes, returns a diff, and you realise it implemented the wrong thing — or the right thing in a way you didn't want. Heavy planning, heavier orchestration, careful review. The implementation phase is then almost mechanical, because every hard decision was made and recorded earlier.
  
  The bet: research is cheaper than rework.