do_skill

Overview

This skill orchestrates structured feature development using a seven-phase loop driven by codeagent-wrapper. It coordinates code-explorer, code-architect, code-reviewer, and develop agents in parallel, ensuring disciplined discovery, design, implementation, review, and delivery. Use the /do command to start a tracked workflow that updates loop state and emits a completion promise when finished.

How this skill works

When invoked with /do <task>, the skill runs a setup script to initialize a per-task state file and then advances through seven phases: Discovery, Exploration, Clarification, Architecture, Implementation, Review, and Summary. Each phase invokes specific agents via codeagent-wrapper, passing a full Context Pack and updating the state file after completion. Hard constraints enforce no direct code writing, mandatory clarification, approval before implementation, and parallel-first agent runs where independent.

When to use it

• When you need a repeatable, auditable feature delivery process tied to the codebase.
• When multiple agents should explore, design, and implement in parallel while preserving context.
• When you require mandatory clarification questions before any design work.
• When you want explicit approval gates before code changes are made.
• When you need end-to-end checks: architecture, implementation, and focused reviews.

Best practices

• Always run the setup script to create the loop state before any agent calls.
• Include the complete Context Pack with every agent invocation so decisions and outputs are passed forward.
• Use codeagent-wrapper --parallel for independent exploration, architecture, or review tasks to speed iteration.
• Never write code directly; delegate all changes to the develop agent via codeagent-wrapper.
• Stop and resolve Phase 3 questions before proceeding; treat Phase 5 as a gated step requiring explicit approval.

Example use cases

• Add a small API endpoint following existing patterns: discovery questions, explorer maps, minimal-change vs pragmatic architecture, then implement after approval.
• Migrate a subsystem interface: run parallel explorers to map usages, clarify API decisions, design a testable seam, then implement via develop agent.
• Introduce a feature flag: discover scope, explore similar flags, architect minimal vs testable approaches, and implement after signoff.
• Refactor for testability: explore current patterns, clarify constraints, propose pragmatic clean plan, and run develop to apply changes once approved.