lukedj78/dev-flow

**📖 Browse every skill →** — one page per skill: what it does, when it applies, what it deliberately doesn't, and the references it ships. Generated from skills.json, so it can't drift from the suite.
The poster above is the interactive map (dark/light): docs/dev-flow-skill-map.html
> **A filesystem contract for agent-driven SDLC.**
> One folder (.workflow/), one state file (meta.json), and **52 skills (10 core + 18 web + 2 agent + 16 mobile + 4 monorepo + 2 refactor)** that read/write it. The contract is the product — the skills are durable, replaceable consumers.
>
> **v1.0.0** — install as a Claude Code plugin: /plugin marketplace add lukedj78/dev-flow then /plugin install dev-flow@dev-flow. Other runtimes (Codex · Copilot · Gemini · Cursor) use install.sh. See the CHANGELOG.
>
> The web family now includes **eve-agent** — scaffold and grow an eve agent as the AI engine behind a Next.js app, opted into via stack.agent. It lives inside the app, in apps/agent, or **alone at the repo root** when the product has no UI at all (three topologies). See docs/example-full-walkthrough.md and the autonomous-loop runbook docs/loop-engineering.md.
>
> **Rule zero — doc-grounded, never invent.** The skills are a second brain: when one says *"use library X"*, it ships the **how** from X's official docs, prefers the **version-matched** source the tool itself ships (next dev maintains an AGENTS.md block pointing at bundled docs; eve ships node_modules/eve/docs), marks fast-moving identifiers [VERIFY], and gets re-verified on a cadence — logged in docs/vercel-changelog-watch.md. The map of every how-to is **docs/knowledge-index.md**.
>
> **Golden rules** (enforced on every project, see the contract): **① code is written in English** (identifiers, constants, comments — independent of the conversation language); **② every frontend ships i18n from day one** — web via next-intl, mobile via the RN i18n stack, minimum locales **English + Italian**, no hardcoded user-facing copy; **③ UI is composed only from the chosen library's primitives** — for shadcn the components the CLI installs into components/ui/ (all of them, at scaffolded), changed only through DESIGN.md tokens and cva variants; never a hand-rolled primitive, never a second component library, never a forked primitive, and a truly new one only as a recorded exception. **The primitive renders the design**: when a board differs, the primitive's cva variants and DESIGN.md tokens are tuned until it matches pixel by pixel, never the board, and converting an existing screen is proved with a before/after pixel diff. Enforced by the design-system lint (design/no-handmade-ui for raw elements and redrawn primitives; undeclared component libraries and the primitives' headless bases are banned imports outside components/ui/), a write-time guard (Claude Code hooks installed at scaffold), spec-review's Standards axis and shadscan's routing.
The skills are **interchangeable consumers** of the contract. Tomorrow you could rewrite any of them in TypeScript, swap one out for a Cursor-flavored variant, or extend with your own — as long as they read meta.json and respect the phase semantics, they compose.
**Your product can ship its own agent-skill.** When what you build ends up with
an API a coding agent could drive, that is a distribution channel most products
never notice they have — and it takes exactly one artefact to open it. Near
feature_complete, dev-flow offers to write it: see
product-to-agent-skill.
**Three stacks today, one contract.** The web stack ships Next.js (or Astro/Vite) + shadcn/Base UI/MUI apps; the mobile stack ships Expo + React Native + NativeWind apps with EAS publishing to the App Store + Play Store; the **monorepo** stack ships both in one turborepo (with apps/web/ + apps/mobile/ + shared packages/). dev-flow (the orchestrator) reads meta.json#stack.framework and routes to the correct family — prd-from-idea and prd-to-tasks are stack-agnostic and used by all three.
---
Why a contract, not just skills
Most "AI agent toolkits" hardcode orchestration in prompts. That works until the conversation drops context — then the agent forgets which step you were on, what design tokens it picked, which modules it wired.
dev-flow fixes that the way distributed systems fix it: **state lives on disk, not in the agent's head.** Every skill is independently re-runnable from .workflow/meta.json. Resume a build the next morning, hand it off to a different agent, run two skills in parallel — the contract holds.