Skills the agent uses

Human-in-the-loop planning: investigates the project and turns it into a complete backlog (epics, tasks, testable AC).

Synthesizes the current conversation into a PRD ready for `agf import-prd`.

Breaks a PRD into atomic XS/S subtasks with acceptance criteria.

Stress-tests a decision by surfacing assumptions and counter-arguments.

Classifies every AC item as specified / partially / unspecified before implementation.

Builds a sprint respecting capacity, WIP=1, and dependency order.

Picks the next task respecting a cost budget — prefers XS/S when it is low.

Builds the backlog end-to-end, autonomously: pulls the next task (WIP=1), implements with TDD, learns, repeats.

Red-Green-Refactor, with one shot through every layer first.

Forbidden phrases and citation requirements for code and rationale.

Defines a deep module's public surface before writing the implementation.

Single in-progress task per agent — finish before starting another.

Hunts and fixes bugs and security issues, and raises test coverage — autonomously, every fix proven by a regression test.

Audits a module's depth ratio and interface surface before merge.

Steps up one abstraction layer to map an unfamiliar area's modules and callers.

Classifies dependencies into 4 seams to plan substitution and testability.

Definition of Done — 9 checks before `agf node status <id> done`.

Compares harness scores before/after a change to gate the merge.

Turns a vague idea into a structured PRD ready for `agf import-prd`.

ANALYZE phase: requirements, PRD and Definition of Ready.

DESIGN phase: ADRs, architecture decisions and contracts.

PLAN phase: smart decomposition, sprint planning and DORA-based estimates.

Drives a feature through all 9 phases, delegating the build and validating gate by gate.

IMPLEMENT phase: TDD Red → Green → Refactor inside the guarded loop.

HANDOFF phase: PR, memory capture and knowledge export.

DEPLOY phase: release, DORA metrics, provider choice and cost proof.

LISTENING phase: captures feedback, keeps the learning and seeds the next cycle.

VALIDATE phase: unified validation, done integrity and scenario checks.

REVIEW phase: blast radius, code-aware sync and diagrams.

Finds and fixes bugs with 5 Whys and a regression test.

OWASP, STRIDE and secrets audit for changes touching auth, external input or data.

Refactoring audit: SOLID, DRY, McCabe complexity and token economy.

Test strategy audit: test pyramid, FIRST principles and coverage.

Documentation health: JSDoc, fresh README and examples that run.

Platform audit for deliveries with a UI: Web Vitals, accessibility and harness.

CTO role: sizes the team, sets priority and scope, scores and coaches each agent.

Leader role: assigns tasks without file overlap and runs the 30-minute rounds.

Worker role: pulls one task, does TDD in its own worktree, proves it as a user and reports.

Reviewer role: reviews without editing, merges what it approves into main and pushes.

Runs the rhythm: a 30-minute standup from the graph, sprint status and retro.

Kanban board with WIP limits, bottleneck detection and flow metrics.

Colony round report: throughput and lead time against the recorded baseline.

Release flow: tag, binaries, website and skills mirror, in the right order.