Getting Started with Agentic Engineering

Agentic engineering is spec-driven development run by AI agents. You do not
hand a coding agent a vague prompt and hope. You write a spec, the agent turns
it into a plan, the plan into tasks, and the tasks into code — with a human
gate at every step. This article gets you from zero to a working pipeline.

The idea in one line

Specs are the source of truth. Code is a build artifact of the spec.

Every feature lives under specs/<NNN-slug>/ and moves through a fixed pipeline:

specify → clarify → plan → tasks → implement → verify → retrospective

Each stage is a slash command (/specify, /plan, /tasks, ...) and each
produces a reviewable artifact (spec.md, plan.md, tasks.md) before any
code is written.

Who does what — the agent hierarchy

You sit at the top. You never write the code yourself; you direct Opus
manager agents, each owning a slice of the work. Each manager fans its slice
out to cheaper Sonnet sub-agents that do the mechanical edits in parallel,
then reports back up.

graph TD
  You["You — repo owner<br/>set intent, approve gates"]
  You --> M1["Opus manager<br/>feature A"]
  You --> M2["Opus manager<br/>feature B"]
  M1 --> S1["Sonnet sub-agent<br/>edit files"]
  M1 --> S2["Sonnet sub-agent<br/>write tests"]
  M2 --> S3["Sonnet sub-agent<br/>edit files"]
  M2 --> S4["Sonnet sub-agent<br/>write tests"]
  S1 -.report.-> M1
  S2 -.report.-> M1
  S3 -.report.-> M2
  S4 -.report.-> M2
  M1 -.summary.-> You
  M2 -.summary.-> You

Rules of thumb:

• You hold context and intent. You approve every spec and plan.
• Opus managers decompose, design, and verify. Expensive, smart, few.
• Sonnet sub-agents execute bounded, obvious edits. Cheap, fast, many.
• The smaller the scope, the cheaper the model. Push work down the tree.

Step 1 — Get Spec Kit

Spec Kit is the toolchain that scaffolds the pipeline. It ships the slash
commands, the templates, and the .specify/ directory.

Install the specify CLI with uv:

# install uv first if you don't have it
curl -LsSf https://astral.sh/uv/install.sh | sh

# install the Spec Kit CLI
uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

Scaffold it into a project (use . for the current repo):

specify init . --ai claude

This drops in:

• .specify/ — templates, scripts, and memory/constitution.md.
• .claude/commands/ — the /specify, /plan, /tasks, ... slash commands.
• specs/ — where every feature folder will live.

Verify:

specify check        # confirms CLI + agent wiring
ls .specify/templates/commands

Step 2 — Update Spec Kit to our rules

The defaults are generic. Before you write a single spec, bend the toolchain to
our rules so every downstream artifact inherits them.

2a. Write the constitution

The constitution is the supreme authority — it beats any prompt, README, or
agent preference. Generate or edit it:

# interactive: derive principles from a conversation
/constitution

# or edit directly
$EDITOR .specify/memory/constitution.md

Bump the version header and add a Sync Impact Report comment at the top
whenever you change it (MAJOR = principle removed/redefined, MINOR = principle
added, PATCH = clarification).

2b. Encode the hard refusals

Our non-negotiables live in Agentic Engineering and the constitution. Make the
agent refuse, not negotiate:

• No CGO, no mattn/go-sqlite3, no SQLCipher.
• No git add . / git add -A — stage files explicitly.
• No JWTs for sessions, no bcrypt, no mocking libraries, no Viper.
• Conventional Commits, imperative subject ≤50 chars.

Put these in the constitution so /plan's Constitution Check enforces them, and
mirror the short list in CLAUDE.md for the human-facing summary.

2c. Tune the pipeline extensions

• .specify/quickfix-guards.yml — what the fast /speckit.quickfix lane is
  allowed to touch without a full spec.
• .specify/extensions.yml — hooks fired around pipeline stages.
• Tag tasks in tasks.md with a model tier (@haiku / @sonnet / @opus)
  and a wave number so /implement can fan them out — this is exactly the
  manager → sub-agent split from the diagram above.

2d. Re-sync templates

After changing the constitution, re-run the affected stages so templates pick
up the new rules:

/plan      # runs the Constitution Check against the new rules

Step 3 — Run your first feature

/specify    a one-paragraph description of the feature
/clarify    answer the open questions it surfaces
/plan       produce plan.md; passes the Constitution Check
/tasks      produce tasks.md, tagged by model tier and wave
/implement  execute the tasks — managers fan out to sub-agents
/verify     trust-but-verify the diff against the spec

Then /speckit.retrospective to capture what to fix in the constitution next
time. See the Roadmap for the queue of features waiting to go through this
loop.

Where to go next

• Agentic Engineering — the agentic engineering hub for this repo.
• Roadmap — the spec backlog and dependency order.
• The constitution: .specify/memory/constitution.md.