Agentic Engineering

Building fast and reliable software with AI.

Source: TBA: a fork of 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.

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.

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.

Map

Problems

• The Illusion of Speed
• The One-Shot Problem
• Losing Control: When the Agent Goes Off-Plan

Practice

• Spec-Driven Workflow
• Model Routing: Haiku, Sonnet, Opus
• Subagents and Context Injection
• Trust but Verify
• The Compounding Layer

The cost of speed is the cost of being wrong fast.