Implementing Features

• Spec+AC required → PreToolUse blocks code edits without spec (formal)
• DRAFT plan blocks code → PreToolUse denies edits when unapproved plan exists (formal)
• Shipped spec protection → PreToolUse denies editing shipped contracts without migration (formal)
• Pattern warnings → PreToolUse shows matching patterns at write-time (all profiles)
• Intelligence push → First code edit pushes conventions, patterns, quality checks automatically
• TDD nudge → Warns if source edits occur before test writes
• Spec drift → Warns if edited file matches contract assertion surface
• Session stop blocked → Can't end session with DRAFT plans or unshipped merges

Before coding

Run ag intel implement F-XXXX for full conventions and quality checks (or wait — the framework auto-pushes a brief on your first code edit).

Quality knowledge references (consult during implementation):

• .agentic/lib/quality_knowledge/security.knowledge.md — OWASP patterns, input validation, injection prevention
• .agentic/lib/quality_knowledge/code_quality.knowledge.md — clarity, error handling, design for testability
• .agentic/lib/quality_knowledge/testing.knowledge.md — test methodology (London vs Classical), test doubles, coverage
• .agentic/conventions.md — universal coding standards (always check)
• .agentic/local/conventions-stack.md — stack-specific rules (if generated by ag quality setup)

Preconditions

• Feature must have a YAML contract at spec/contracts/F-XXXX.yaml with assertions
• Contract lifecycle must be specifying or later (not exploring)
• If pending user_input exists on the contract, process it first (write tests → implement → migrate → clear)

Capture corrections

When the user corrects your approach or expresses a preference, capture it: ag intel remember "what they said" --context "what you were doing"

Contract & test impact check

After making code changes, grep spec/contracts/ for assertions related to the changed behavior. If any are affected, STOP — present the affected assertions to the user and wait for approval before modifying any contract or test. Contracts protect shipped behavior; silently updating them to match new code defeats that protection.

Documentation (before creating PR)

Docs are part of the deliverable — update them alongside code, not after merge.

1. Check freshness: bash .agentic/lib/tools/docs.sh --check-freshness --trigger feature_done --manifest F-XXXX
2. Update each stale doc relevant to your feature
3. Include doc changes in the same PR as code
4. For complex doc work, use the updating-documentation skill

For framework development: also update instruction files (CLAUDE.md template, memory-seed, DEVELOPER_GUIDE, HOW_IT_WORKS, etc.) — see DEV-003.

Context-Optimized Delegation (MCP + Agent tool)

When the agentic-coord MCP server is available and the feature has 2+ acceptance criteria, delegate each AC to a fresh-context subagent instead of implementing directly. This keeps the orchestrating session lean and avoids context exhaustion on large features.

Delegation workflow:

1. Call MCP list_acs(feature_id) to get criteria and completion status
2. For each pending AC: a. Call MCP get_delegation_prompt(feature_id, ac_id) → returns {prompt, model_hint, use_worktree} b. Spawn: Agent(prompt=result.prompt, model=result.model_hint) — subagent implements in fresh context c. After return: call MCP save_progress(feature_id, ac_id, status, note) with the result d. Call MCP get_next_action(feature_id) to determine the next step
3. After all ACs: get_next_action returns "verify" — delegate verification to another subagent
4. After verify: create PR from the orchestrator (needs user interaction)

When to use:

• Feature has 2+ ACs → always delegate
• Feature has 1 AC → implement directly (delegation overhead not worth it)
• MCP tools not available → implement directly (fallback, no breakage)

Retry on failure: If a subagent fails an AC, get_next_action will return it again with an incremented attempt counter. Prior failure notes are included in the next get_delegation_prompt. After 3 attempts, report the failure to the user.