Runs a disciplined, doc-driven workflow that takes software work from issue to a reviewed, merge-ready change. It reads each repository's own docs at runtime, so the same process works on any stack and any agent that reads skills.
Claude Code
> /plugin marketplace add gtrabanco/agentic-workflow> /plugin install agentic-workflow@agentic-workflow
Codex
$ npx skills add gtrabanco/agentic-workflow -a codex
Cursor
$ npx skills add gtrabanco/agentic-workflow -a cursor
Gemini CLI
$ npx skills add gtrabanco/agentic-workflow -a gemini-cli
GitHub Copilot
$ copilot plugin marketplace add gtrabanco/agentic-workflow$ copilot plugin install agentic-workflow@agentic-workflow
OpenCode
$ npx skills add gtrabanco/agentic-workflow -a opencode
Windsurf
$ npx skills add gtrabanco/agentic-workflow -a windsurf
A reusable set of agent skills that run a disciplined, doc-driven workflow for building software with agents — from idea/issue to a reviewed, classified, merge-ready change. The skills are project-adaptive: they discover and obey each repository's own guide, architecture, roadmap and style docs at runtime, so the same workflow works on any stack.
They are plain Markdown (SKILL.md files), so they work with any agent that
reads skills — Claude Code, Cursor, Codex, OpenCode, Cline, and
70+ others — installed with the
skills CLI (see
Install).
The examples in
docs/are generic and illustrative; the skills themselves are stack-agnostic and architecture-agnostic.
The model-agnostic install (
npx skills add gtrabanco/agentic-workflow) carries no skillmodel:/effort:frontmatter — every skill simply inherits whatever model and effort your agent session is already using. The goal: using this workflow should never lock you into one vendor's model lineup — you pick the model, the skills just run the discipline.
skills/ 28 source skills (13 user-facing + 14 workflow internals + 1 metadata-internal; 27 discoverable — skill-lint is repo-only)
packages/ companion npm packages: @gtrabanco/agentic-workflow-schema (machine contracts)
and @gtrabanco/pi-agentic-workflow (one-command install for Pi — see Install)
template/ the exportable documentation scaffold (the substrate the skills read)
docs/workflow/ the full tutorial (feature flow, issue flow, reference, replication)
docs/features/_TEMPLATE feature SPEC template + ROADMAP (the planning artifacts skills produce)
docs/fix/ fix SPEC template + index
.github/ issue + PR templates the workflow expects
Dogfooding model (authoring): repo sessions consume the workflow from the
installed release (Pi package / installed plugin), not from the working copy.
The committed layout carries no working-copy activation surface. Authoring
sessions opt in by creating a local, gitignored mount
(ln -sfn ../skills .claude/skills) or by exercising a single working-copy
skill via per-session flags (e.g. pi --no-skills --skill skills/<name>/SKILL.md).
The skills are the behavior; template/ is the substrate they read (a
generic AGENTS.md + documentation map, SPEC/feature/fix templates, and GitHub
templates). Scaffold a new project's way of working with
npx degit gtrabanco/agentic-workflow/template my-project — see
docs/workflow/REPLICATE.md.
The largest skills use progressive, one-hop loading instead of paying their full
instruction cost at activation. In particular, execute-phase now activates at
about 3k estimated tokens rather than 13k, then loads only the route-specific
contracts it needs. Committed budgets enforce that shape; prompt caching is only
an optional provider optimization, never a correctness dependency. See
Context budget and progressive loading.
13 user-facing skills (one menu entry each) + internal contracts composed
for you: the lane's triage-driven step selection (unit-lane), the executor
(execute-phase), the internal review pack (review-code, review-security,
review-verify, review-debt, review-design, review-a11y, review-brand,
review-perf, review-seo), the workflow's own pre-execution evidence owner
(pre-execution-review), the orchestration-envelope contract, and the repo-only
skill-lint maintenance helper (excluded from installation) — so no external
review skill is ever required, on any agent, with any model. One disciplined
path: triage → catalog steps (design, implement, tests, evidence, review) →
review the change → audit → merge.
Every skill's invocation forms and flags (
--fix,--force,--adversarial N,--next,--fullauto, …) are catalogued in the Invocation & arguments reference.
Provisioning this repo's own authoring toolchain (bun, uv + serena-agent, engram, the
gentle-engrampi package)? Runnode scripts/setup-env.mjs— the full guide isdocs/workflow/SETUP.md.
| Skill | What it does |
|---|---|
init-workspace | Fetches and adapts template/ by interview: gate, doc map, architecture, capability inventory, optional invariants, and injection-safe labels. It detects Claude Code, Cursor, Copilot, or OpenCode and offers the repository-scoped safety guard explicitly — never installs or overwrites hooks without consent. Existing scaffolds enter upgrade mode (additive: only missing blocks/adapters) which also reconciles and retires a legacy CLAUDE.md into AGENTS.md, and only with consent — a client that reads only the old name may keep it. Consent is mandatory and never defaulted: a consent gap runs the three-tier dispatch and stops with the open-questions@1 block. Provision Serena end to end on one consent question: the tool (uv tool install -p 3.13 serena-agent + serena init, pipx on the MCP path only), the detected platform's MCP registration, the consent-gated append to the global trusted_project_path_patterns, and the project config — .serena/project.yml with fixed markdown+json entries plus detected languages (typescript, python, yaml when .yml present, etc.) and the .gitignore block. Then it reports exactly what it installed and registered, and enforces the startup rule (a failing server is dropped, never left dead; LSP evidence stays TypeScript/JavaScript-only). A refusal installs, registers and writes nothing. |
discover-repository-state | Creates and freezes an evidence-backed repository-state ledger before planning or implementation; facts, decisions, documentation, planned work, and inference remain distinct |
resolve-repository-state | Sole writer for an explicit repository-state contradiction; verifies the competing evidence and publishes the next frozen snapshot |
| Skill | What it does |
|---|---|
execute-phase | Executes one phase per turn (<NN> P<k>, tier attached) with its own acceptance-blob check, phase/invariant/dependency gates, tests, docs, and commit — the closing hand-off names the next single phase and the catalog tier, and resumes unit-lane after the last phase. Looping all remaining phases (<NN> with no phase) is an explicit operator choice only. Halts on red/no-progress/attempt budget. Discoveries become Autofix, Opportunistic Fix, or a proposal—never an automatic issue. Each phase's pre-flight runs bun scripts/phase-lint.mjs <plan> and pastes its output. The whole-unit close-out settles the roadmap row through the crate's writer (bun scripts/roadmap-settle.mjs exits 0, issue #316). It never interviews: a missing input runs the three-tier dispatch and then scripts/needs-input.mjs prints the open-questions@1 block and the run stops, routed back to the stage that owns the fact. |
| Skill | Scope | What it does |
|---|---|---|
review-change | the change | Runs only the reviews that apply to your platform (code, security, verify, design, a11y, brand, perf, SEO) — adversarially by default, assuming the diff is wrong until proven otherwise — and classifies → one decision table + an explicit manual-verification checklist; a dirty tree or unpushed commits stop the review as a REVIEW BLOCKED precondition before any pass runs — workspace state is never a persisted finding, and the review commits its own findings append so it never dirties the tree it next judges. The mandatory end review must run in a conversation that did not implement the change — if it did, stop and hand off to a fresh one. Opt-in --adversarial N: N independent context-clean reviewers, each an index-assigned role (correctness/security/SPEC-coverage), run in parallel (subagents / headless / sequential-fallback), findings merged by file:line at an inclusion threshold of ≥1 — default off, auto-recommended (never forced) when the change is L/sensitive, the reviewer isn't the fleet's strongest or is weaker than the diff's author, or only one model family is available on a ≥M change. --synthesize is the standalone fusion entry point for manually-run reviewers. Fix-now findings on an unmerged unit persist to that unit's fix-now fold ledger — its ## Findings section for a migrated unit, review-findings.md for a legacy one, probe-first and never both — deduped by file:line+axis (only high/med persist — low findings are report-only notes that never block). Classification honors the engine's fix-now override checks: a cheap fix or an in-scope defect is always fix-now (never a postpone/known-issue/tradeoff escape), and a too-large in-scope fix-now routes to replan-in-unit — user-confirmed SPEC phase(s) on the same branch, never a downgrade. Its review charter: try to dismantle the claim that what works, works and works well — in-scope bugs, security issues and guard skips are this review's own findings, expectations are asked about rather than inferred, and the repo-wide bug/security/broken-version hunt belongs to product-audit |
fold-findings | the findings ledger | Repairs the full queue in the fewest compatible atomic batches, grouping by root cause/mechanical rule + validator + rollback boundary. One batch gets one commit, while every finding retains its ledger tick and output receipt. Classification stays frozen; disputes stop for a user decision and no fold creates backlog. A token- or claim-shaped change carries its swept: declaration, which promise-coherence re-runs. |
Stars on GitHub
Helps you take a change from a rough idea or bug report through to a tested, reviewed result, with each step handled by a focused skill. Its skills cover pinning down domain terms, designing module interfaces, diagnosing hard bugs, and reviewing changes against your repo's coding standards.
@mattpocockA development methodology for coding agents that makes the agent brainstorm before building, follow plans, run parallel work and finish branches in a disciplined way. You get fewer skipped steps and more consistent results from your coding assistant.
@obraGives your coding agent a planning, testing and review routine to follow on every task. It plans before building, checks changes with tests, has a fresh reviewer look for regressions, and saves repeated wins as reusable skills.
@affaan-mDeveloper tools for working on the React codebase itself. Provides skills for extracting error messages, managing and debugging feature flags across release channels, running Flow type checks, and fixing lint and formatting issues before committing.
@facebookInstall it with the command on its page. It includes audit-docs, audit-pr, discover-repository-state. Its skills do not fire on their own yet. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it