implement-flow

Implements features autonomously through decompose, implement, review, verify, and commit cycles.

5|Updated Sep 9, 2017
One-click install
npx skills add https://github.com/hpcsc/dotfiles --skill implement-flow-hpcsc
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: implement-flow
Source: https://github.com/hpcsc/dotfiles/tree/main/link/common/dot-config/.config/opencode/skills/implement-flow
Command: npx skills add https://github.com/hpcsc/dotfiles --skill implement-flow-hpcsc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Manually driving a feature from story to landed branch requires constant human supervision at every step. This Skill runs the entire implementation loop unattended — decomposing a story into tasks, running each through test-design, implementation, refactoring, and review, then closing tasks only on executed evidence and committing them to a dedicated feature branch. ## Core Features & Use Cases - Autonomous task cycles: Decomposes a user story into tasks and runs each through test-case design, language-specific implementation, refactoring, and triaged code review via subagents. - Evidence-based closure: Replaces human approval gates with an independent verifier that re-runs the test command, reproduces reviewer findings, and maps every acceptance criterion to executed evidence before committing. - Plan adaptation and learnings: Detects when mid-run learnings invalidate the remaining plan, re-decomposes remaining tasks, and persists durable learnings across runs. - Use Case: Hand it a well-scoped story on a fresh feature branch, let it run unattended, and review the resulting commits as a branch or PR afterward. ## Quick Start Ask the agent to implement your user story end-to-end on a dedicated feature branch using the implement-flow skill, then review the resulting commits afterward.

Frequently Asked Questions about implement-flow

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a feature autonomously without human approval gates?▼

Provide a well-scoped user story on a clean git tree; the flow decomposes it into tasks and runs each through implement, review, and verify cycles unattended. Human gates are replaced by an evidence-closure verifier that re-runs tests and checks acceptance criteria before committing.

How does evidence-based task closure work in autonomous coding?▼

Each task closes only when the test command re-run passes, every acceptance criterion maps to executed evidence such as a named passing test, and no reproduced runtime or high-severity quality finding remains open. Claims must be backed by raw command output, not assertions.

Can I resume an interrupted autonomous implementation run?▼

Yes. Pass an existing tasks/*.md file as the argument and the flow adopts it, skipping decomposition and resuming from the first unchecked task in the progress checklist. Completed tasks marked with checked boxes are left untouched.

When should I not use an unattended implementation flow?▼

Avoid it for changes that are hard to reverse or reach outside the repo, such as migrations against shared state, deploys, or destructive operations. It is also unsuitable when you want to steer decisions at each step, since it auto-commits without human gates.

Does the flow support Go projects managed with mise?▼

Yes. It checks the project's mise config for a declared Go toolchain and, if found, wraps all Go commands with mise exec. The prefix is decided once up front and reused for every build, test, and vet command in the run.