workflow
/workflow
Delivery loop for building software with a coding agent, from rough idea to verified, committed change. Use when starting a feature or bugfix, when asked to plan or break work into tasks, when setting up how an agent or team works, before committing or merging, and when asking whether something is done.
Assessment and security
- Files in this package
- 5
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 2
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Delivery loop for building software with a coding agent, from rough idea to verified, committed change. Use when starting a feature or bugfix, when asked to plan or break work into tasks, when setting up how an agent or team works, before committing or merging, and when asking whether something is done.
Original author description
Delivery loop for building software with a coding agent, from rough idea to verified, committed change. Use when starting a feature or bugfix, when asked to plan or break work into tasks, when setting up how an agent or team works, before committing or merging, and when asking whether something is done.
How it works
- The loop
- Always on
- What to read for which task
- Which sibling skill takes over
- Gates
- Deeper process, optional
- Keep project facts in the project
SKILL.md preview
--- name: workflow description: Delivery loop for building software with a coding agent, from rough idea to verified, committed change. Use when starting a feature or bugfix, when asked to plan or break work into tasks, when setting up how an agent or team works, before committing or merging, and when asking whether something is done. --- # Workflow How to take a piece of work from "someone asked for it" to "verified, committed and reported". It works with any coding agent and any stack. It sets the order of work and the gates between steps; the domain skills (`ui`, `ux`, `motion` and the others listed below) hold the craft. In this skill, **the decision owner** is the person who owns the product decision: the one who says what "right" looks like, approves directions and authorises anything that leaves the machine (push, PR, merge, deploy). On a solo project that is you; on a team it is whoever the team names. ## The loop Every non-trivial task goes through these steps in order. A one-line fix can skip planning, never verification. Before each step, read its section in `references/delivery-loop.md` (§N matches the step number). 1. **Inspect** (§1). Read the repository and the existing implementation before proposing anything: the code around the change, its tests, the project's agent notes (`AGENTS.md`, `CLAUDE.md` or equivalent), `PRODUCT.md`, `DESIGN.md`, `CONTEXT.md` and ADRs when they exist. 2. **Clarify** (§2). Ask until the outcome, the workflow, the rules, the scope, the states and the success criteria are clear. Do not plan or implement on a guess. One question at a time, with your recommended answer, works best. 3. **Plan** (§3). Break the work into bite-sized tasks, each with its files, its test and its done condition. For anything user-facing, write the user flow and the user stories first: good UX is planned, not patched. 4. **Implement test-first** (§4). Red, then green, then refactor, for every feature and every bugfix. One fresh implementer per bounded task; a reviewer per task (spec compliance first, then quality). For a bug, start with §4 Debugging (reproduce, root cause, regression test). 5. **Review** (§5). After substantive work, run a code review on the whole change. Resolve every confident, material finding, then review again. UI is reviewed by the decision owner on a mockup, not by an automated visual pass. 6. **Verify** (§6). Run the checks and read their output before saying anything works. Evidence before claims. 7. **Report** (§7). Say what is done and what remains, in the RESULT format, and separate implemented, tested, reviewed, committed, pushed, merged and deployed. ## Always on 1. **Clarify before building.** If any of outcome, workflow, rules, scope, states or success criteria is unclear, ask. A wrong build costs more than a question. 2. **Tests first.** No production code without a failing test that it makes pass. A bug gets a regression test before its fix. 3. **One bounded task per implementer, a reviewer per task.** Parallelise only read-only work or tasks whose files do not overlap. On a machine with little memory, run them one at a time. 4. **Deterministic checks before AI review.** Types, lint, tests, build and static accessibility checks run first; an AI reviewer reads code that already passes them. 5. **No claim without evidence.** "Done", "fixed" and "passing" follow a command you ran and output you read in this session. 6. **Nothing leaves the machine without a go.** No push, PR, merge or deploy until the decision owner says so for this change. 7. **Use what is installed.** When a skill or tool already covers the job, use it; do not rebuild it as an ad hoc prompt or a custom agent. Use one planning system per feature and one design authority at a time. ## What to read for which task All paths are relative to this skill folder. | Task | Read | |---|---| | Anything with a UI: inspect first, component source order, mockup-first, checks before "done" | `references/ui-work.md` | | Branches, staging, commits, what needs authorisation | `references/git.md` | | STATUS and RESULT blocks, the delivery states, drafting emails and messages | `references/communication.md` | ## Which sibling skill takes over This skill decides when and in what order; these skills decide how. Load the one that matches the step. | Step or need | Skill | |---|---| | Building, restyling, polishing or critiquing a screen; the mockup-first loop and its states checklist | `ui` | | Interface copy, errors, empty states, edge cases, accessibility | `ux` | | Any animation or motion | `motion` | | Before calling any UI done: the 20 tells and the detector | `anti-slop` | | A deep, multi-lens design audit of a file, component or route | suggest `/design-grill` to the user (costly, their call) | | Visual references before designing | `design-inspiration-index` | | Prose, articles, docs, README and email copy, in English or French | `writing` | | French copy (Québec or France) | `french-typography` | | A site that collects personal information in Québec | `loi-25-website` | | Starting a SaaS, dashboard or web app | `saas` | | Starting a showcase site for a local business | `vitrine` | The project-type playbooks (`saas`, `vitrine`) give the order of design work for that kind of product; this skill wraps them with the clarify, plan, test, review, verify and report gates. ## Gates A step does not start until the gate before it is met. | Before | The gate | |---|---| | Planning | Outcome, workflow, rules, scope, states and success criteria written down and confirmed | | Implementing UI | User flow and stories written; for new or restyled screens, the mockup approved by the decision owner | | Each task's code | A failing test that fails for the expected reason | | Moving to the next task | The task's reviewer passed it on spec, then on quality | | Committing | Repository checks green; only the task's files staged | | Saying "done" | Fresh verification output read; RESULT block written | | Push, PR, merge, deploy | Explicit authorisation from the decision owner for this change | ## Deeper process, optional This skill is self-contained. If you want a fuller, opinionated version of a step, these open collections go deeper. They are recommendations, not requirements, and nothing here depends on them. - [Matt Pocock's skills](https://github.com/mattpocock/skills): `grilling` and `grill-me` (clarify), `grill-with-docs` and `domain-modeling` (repository-aware interviews, shared vocabulary, ADRs), `to-spec` and `to-tickets` (spec then tickets), `tdd`, `diagnosing-bugs`, `codebase-design` (module boundaries), `code-review`. - [Superpowers](https://github.com/obra/superpowers) by Jesse Vincent: `brainstorming`, `writing-plans`, `subagent-driven-development`, `test-driven-development`, `systematic-debugging`, `requesting-code-review`, `verification-before-completion`, `using-git-worktrees`, `finishing-a-development-branch`. Pick one planning system per feature. A spec-and-tickets flow from one collection and a full plan from the other, run on the same feature, produce two sources of truth. ## Keep project facts in the project Project-specific rules (stack, commands, tokens, terminology, decisions) belong in the repository: its agent notes file, `PRODUCT.md`, `DESIGN.md`, `CONTEXT.md` and ADRs. This skill stays generic. One-time setup steps (installing a design context, configuring a skill for the repo) run once per repository, not on every task.
Files in this package (5)
- SKILL.md 7 KB
- references/communication.md 3 KB
- references/delivery-loop.md 7 KB
- references/git.md 3 KB
- references/ui-work.md 4 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · molveau/skills | 90 | MIT |
| jeremylongshore/tons-of-skills-marketplace | 100 | MIT |
| SimHacker/moollm | 100 | MIT |
| mlophez/polix-ai | 100 | Apache-2.0 |
| stellarie/minimal-agent-kit | 100 | MIT |
| waynesutton/builder-skills | 100 | Apache-2.0 |
| claude-world/director-mode-lite | 100 | MIT |
| DawitLemmaBalcha/agent-workflow | 100 | MIT |
| zhinkgit/embeddedskills | 100 | MIT |
Database snapshot: 13.11.2026 · package version 11c44a3f1826 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100team-lead
Use when the user hands off a feature, change or rough need to the agent team, wants to shape it with a team lead, or asks the team to take work from idea to pull request. For a request to only create a ticket, use the klearframe-agent-team:linear-ticket skill. - 100feature-workflow
Use when building any user-facing feature, from the request to the last commit - spec, plan, tests first, browser check, end-to-end tests and improving the harness. - 100dev-spec
Spec-driven development workflow skill for product requirement intake, engineering research, technical planning, task breakdown, implementation, testing, bugfix loop, and engineering review. Use when a user wants to run or continue a structured software delivery workflow with… - 90agent-debugging-workflow
Work with an agent on a bug by supplying evidence and letting it form hypotheses, rather than asking it to guess from a description. Use when debugging with an agent's help. - 100tincan
Pair with another coding agent over an end-to-end encrypted WebRTC data channel to hand off tasks, sync context and exchange file patches. Use when the user asks you to collaborate directly with another agent on a different machine. - 90proviso-build
Build an amendment of a Proviso spec tree with a testing agent and a coding agent, kept apart, until its integration is green and no gap is open. Use when the engineer asks to build, implement or run the forward round of an amendment whose tree change is committed on its branch.…