dev-flow
/dev-flow
The spec-driven development loop for shipping a feature/fix fast and safely on top of a GitMark KB — research → tasks → goal → spec (markdown via skills) → isolated git worktree → implement → tests → independent review → dev-tests → prod-tests → ship (MR → dev → main). Use when starting a feature or fix, or when asked "how do we build/ship a change here".
- Author
- vakovalskii ↗
- Repository
- ontoship ↗
- Licence
- MIT
- Last repository change
- 16.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 16.10.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
The spec-driven development loop for shipping a feature/fix fast and safely on top of a GitMark KB — research → tasks → goal → spec (markdown via skills) → isolated git worktree → implement → tests → independent review → dev-tests → prod-tests → ship (MR → dev → main). Use when starting a feature or fix, or when asked "how do we build/ship a change here".
Triggers from the description
Original author description
The spec-driven development loop for shipping a feature/fix fast and safely on top of a GitMark KB — research → tasks → goal → spec (markdown via skills) → isolated git worktree → implement → tests → independent review → dev-tests → prod-tests → ship (MR → dev → main). Use when starting a feature or fix, or when asked "how do we build/ship a change here".
How it works
- The loop
- Git-flow
- Principles
- When to apply
SKILL.md preview
---
name: dev-flow
description: The spec-driven development loop for shipping a feature/fix fast and safely on top of a GitMark KB — research → tasks → goal → spec (markdown via skills) → isolated git worktree → implement → tests → independent review → dev-tests → prod-tests → ship (MR → dev → main). Use when starting a feature or fix, or when asked "how do we build/ship a change here".
---
# dev-flow — from idea to production
A battle-tested loop for shipping with an AI agent: a feature reaches production in
roughly **40 minutes to 2 hours**. The spec is plain **markdown written via the KB
skills**, the work happens in an **isolated git worktree**, and **only green reaches
prod**. The KB (see `kb-curate`) is the carrier of knowledge — onboarding, hand-off and
scaling all start from it, not from the code.
## The loop
1. **Research** — understand from facts, not guesses: read logs, traces, and the code
itself. Reproduce before fixing.
2. **Tasks** — turn the research into a list of tracked tasks with dependencies. Nothing
gets lost.
3. **Goal** — crystallize one clear goal and the "done" criterion from those tasks.
4. **Spec** — write it as markdown in the KB via **`kb-curate`** (ontology: `node_type`,
frontmatter, typed links `links.documents: [src/…]`). The spec is durable knowledge,
not a throwaway ticket — searchable, linkable, graphable.
5. **Isolate** — work in a dedicated **`git worktree`**: `main` stays untouched, parallel
agents don't collide, and rollback is just dropping the worktree.
6. **Implement** — code to the spec inside the worktree; keep doc↔code linked
(`implemented_by`).
7. **Tests** — write/adjust unit + E2E for the feature. The test is part of the feature,
not an afterthought.
8. **Independent review** — run an **independent model** (e.g. Codex CLI, read-only) over
the diff for logic and security bugs before rollout. A second model catches what the
author's model misses — on a real production codebase this pass caught **191 bugs**
before they reached prod.
9. **Dev-tests** — open an **MR with the commits into the `dev` branch**; run the full
suite there. Red → fix in the worktree, don't merge.
10. **Prod-tests** — E2E/smoke against the **real prod contour**, not only mocks or dev.
Verify behaviour where users live.
11. **Ship** — merge **`dev → main`** and deploy (build the new image *before* stopping the
old container, then poll the healthcheck to measure real downtime).
## Git-flow
```
git worktree → MR + commits → dev branch (dev-tests) → main (prod-tests + deploy) → prod
```
## Principles
- **Spec = markdown + skills.** No ceremony, but ontological — so it stays searchable,
linkable and graphable (`kb-search` / `gitmark map`).
- **Worktree isolation by default** — clean parallelism and clean rollback.
- **Tests and independent review are gates, not afterthoughts.**
- **Verify on prod**, not just dev.
- **md + git = source of truth**; everything derived (search index, graph) is regenerated.
## When to apply
Starting any non-trivial feature or fix. For a one-line change you can collapse steps,
but keep the gates (review + tests) — they are where the 191 bugs were caught.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · vakovalskii/ontoship | 100 | MIT |
| cookys/autopilot | 100 | MIT |
| lukedj78/dev-flow | 100 | MIT |
| cookys/autopilot | 95 | MIT |
| cookys/autopilot | 95 | MIT |
| cookys/autopilot | 95 | MIT |
| cookys/autopilot | 95 | MIT |
| cookys/autopilot | 95 | MIT |
| cookys/autopilot | 95 | MIT |
Database snapshot: 13.11.2026 · package version 77bf8155e6f3 (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
- 100feature-dev
Feature development workflow. Use when: implementing features, writing code, running dev loop. Not for: understanding code (use code-explore), reviewing code (use codex-code-review). Output: implemented feature + tests + review gate. - 100workflow-build-feature
Build a feature end to end: spec and TDD, implement, unit tests, Playwright check, PR. Use when "build a feature" or "implement this end-to-end". Spec/TDD loop only → workflow-spec-tdd. One bug → workflow-fix-and-ship. - 100ship
Full-cycle development workflow for any non-trivial feature or fix. Runs up to 10 phases (explore+interview loop, plan, implement, verify, edge cases, e2e tests, code review, security review, final verify) using the strongest available model for planning and autonomous goal… - 100dx-agent-dev
Dev Agent: implement code from an RE spec — implement, self-check (build/test/lint), fix failures, commit. Use for 'dev agent', 'implement from spec'. - 100spec-driven-dev
Use when starting any non-trivial feature, refactor, or new project that will touch more than one file. Drives an AI coding agent through a gated Spec → Plan → Build → Test → Review → Ship lifecycle so work is specified before it is built, verified before it is reviewed, and… - 100typescript-dev
Use when implementing a TypeScript feature or fix, or when the user requests TypeScript architecture, implementation, review, or tests.