agentic-workflow

Periodic, product-wide health check — the CTO's "where do we actually stand?" Sweeps the WHOLE codebase (not a diff, not a PR) across every applicable axis — correctness, architecture, security/cybersecurity, performance, tests, UX/UI, accessibility, SEO, brand, tech debt — PLUS process & docs (incomplete phases, aging issues, solvable known-issues, doc/workflow completeness) and roadmap coherence. Mines accumulated suggestions from feature docs. Output: a severity-ranked report and concrete PROPOSALS — issues to open, roadmap features to add or remove. Every run is persisted to docs/audits/<n>-<YYYY-MM-DD>.md with an incremental audit id and findings numbered F1, F2, … so any finding is addressable later as "triage-issue <audit-id> F<k>". NEVER auto-fixes; the user decides what to act on. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits

Classify an issue and take a defensible decision: fix-now, postpone (deferred/trigger-based), wontfix, or promote-to-feature. Reads the issue's own "when to fix"/trigger and severity, verifies the trigger against the CURRENT codebase (counts consumers, checks thresholds, measures), then routes or reports with a dated, auditable comment. Also triages product-audit findings ("triage-issue <audit-id> F<k>"): reads docs/audits/<audit-id>-*.md, verifies the finding, and opens the GitHub issue only if the verdict warrants it. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "triage issue N", "should we fix #N now", "classify this issue", "is #N's trigger met", "what do we do with #N".

Turn an idea or a feature request into an exhaustive, checkable product definition — the stage before engineering planning. The core mechanism is **capability closure**: a checklist that forces every entity, capability, and role a feature introduces to be walked to its full surface (CRUD + state transitions + UI entry point + API + test, or an explicit design-time `n/a`), so non-frontier executor models stop silently omitting the implicit work ("auth with dashboard management and ACLs" must not collapse to a users table + a list view). Closure has three fixed checklists: **entity closure** (each entity to full surface), **integration closure** (the feature reconciled against every subsystem in the project's capability inventory, `docs/CAPABILITIES.md` — auth, ACL, navigation, notifications, …), and the **role matrix** (every inventory role explicitly allowed/denied per capability) — plus an **expectation sweep** that forces what a competent human would implicitly assume ("a blog has drafts") into in-scope/out

Implement one phase of a feature (default), or a small feature / a fix (--fix) by its SPEC's ## Phases ledger — one phase per invocation, the final phase is always Hardening & PR (the close-out); legacy SPECs without ## Phases run end-to-end in a single pass. Enforces branch safety, issue policy, the project's verification gate, and per-phase doc discipline. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "execute phase P1 of NN", "implement the NN feature", "build NN from its spec", "execute-phase NN P2", "execute-phase --fix".

Bootstrap a project's way of working: fetch the agentic-workflow documentation scaffold (template/) and adapt it to THIS project by interview — fill the CLAUDE.md documentation map, gate commands and architecture, prune doc folders that don't apply, keep the SPEC/feature/fix and GitHub templates — then offer to install the skills. The adaptive counterpart to a raw `npx degit` copy. On a repo that already has the scaffold, detects it and switches to **upgrade mode**: diffs the project's substrate against the current template, reads `docs/workflow/MIGRATION.md`, and proposes only the blocks the project is missing — never clobbering a tailored one. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "set up the agentic workflow here", "init-workspace", "scaffold this proje

Internal step of plan-feature: turn a feature-request issue into a scoped, sized, roadmap-mapped SPEC **product half** (capability closure satisfied) with Closes #N traceability.

Internal step of plan-feature: from an already-designed SPEC (product half `designed`), fill the **engineering half** and generate the planning artifact set scaled to the feature's size (XS/S → SPEC-only with ≥ 2 phases in the SPEC, last = Hardening & PR; M/L → full set with a hardening phase) and register the roadmap entry. Docs only — never code.

Plan a fix: a senior-architect persona that drafts docs/fix/<n>-<topic>/SPEC.md from a GitHub issue, scopes it tightly, surfaces blockers and risks — always with a phased execution ledger (≥ 2 phases; the final one is Hardening & PR) — then commits locally on a fix branch and stops for review. The fix-flow analogue of plan-feature → execute-phase: hands implementation off to execute-phase --fix. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "plan a fix for issue N", "draft the fix spec for #N", "scope fix #N", "plan-fix N".

Platform-adaptive review orchestrator. Reviews the current change by running review-implementation (find → classify) AND the workflow's own internal review pack — only the passes that apply to this project and this change (review-code, review-security, review-verify, review-debt, review-design, review-a11y, review-brand, review-perf, review-seo) — never the inapplicable ones (no a11y/SEO/brand for a CLI, library, or infra change). Self-contained: no external review skills required; installed platform skills run as optional extras. Synthesizes one classified report plus an explicit manual-verification checklist. Findings only — never refactors. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "review this change", "full review before merge", "review-change", "run the

Internal findings engine composed by review-change (and reused by the audit skills): two-phase find → classify pass ending in a classified decision table (fix-now / postpone / ignore / intentional-tradeoff). Findings only — never refactors.

Take a review/audit findings ledger (`review-findings.md`) or an `audit-pr` BLOCKED verdict's blocker list and truly repair each fix-now finding — closing the escape hatches a lazy or weak model reaches for: a known-issues/backlog dump, a `decisions.md` tradeoff note, a downgraded severity, a skipped/loosened test, a lint suppression, or a `TODO` stub. One finding at a time, root-cause fix, gate green, committed and pushed, ledger row ticked `folded: yes` with the sha. Triggers: "fold the findings", "fold the review findings", "fix the review findings", "repair the audit blockers", "fold-findings".

Read-only sensor for orchestrating the workflow programmatically: computes the full state of the project — every feature and fix with its dependency closure (met/unmet), pending fixes, open/merged PRs and their audit state, findings awaiting triage, what is startable right now and in which build order, and whether a product-audit is due — and emits it as one machine envelope (fixed JSON). The sensor an external driver calls between steps instead of relying on ship-roadmap's conductor. Never edits anything. Triggers: "workflow status", "what can I build next", "dependency tree of the roadmap", "pending fixes", "state of the run", "workflow-status".

PR-level merge gate. Audits the WHOLE pull request (not just the diff) against a merge-readiness contract: SPEC acceptance criteria met, all phases complete, docs updated per the doc map, Closes #N present when issue-born, tests added at the right layer, CI green, branch off the default branch and independently mergeable, the review-change axes clean (or consciously deferred to tracked issues), and the governing feature SPEC's capability closure taken and recorded (closure-integrity gate — legacy SPECs warn, never block). Verdict: merge-ready, or a ranked list of blockers — always with the PR's full URL printed, and on MERGE-READY a dated, SHA-bound comment posted on the PR itself. Never edits; never merges by default — with a documented auto-merge policy (or an explicit user instruction) it merges a MERGE-READY PR after a fail-closed pre-merge checklist (clean tree, nothing unpushed/unpulled, fresh green CI on the audited SHA). On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#cl

Internal contract of the agentic-workflow pack: the machine envelope — the fixed JSON block an external orchestrator parses to route the next step (which command, which model tier) without a human reading the chat. Skills do NOT emit it on their own (except workflow-status, the sensor): a driver that wants it injects the canonical system-prompt snippet defined here and runs the repair loop on parse failure. Not a menu entry; this skill owns the schema, and docs/workflow/ORCHESTRATION.md documents the driver loop that consumes it.

Internal skill for the agentic-workflow repo. After editing one or more SKILL.md files, bumps their `version:` fields and updates every piece of documentation in the repo that must stay in sync: CHANGELOG.md, CHANGELOG.es.md, README.md, and README.es.md. Run before committing any skill change. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Trigger phrases: "bump the skill version", "update the version", "update the changelog", "I just changed a skill", "log this change", "version bump".

End-to-end autopilot: found the project if needed (one upfront interview — product, features, stack, architecture, quality bars, ops, autonomy, budget), create or adopt the complete roadmap, then ship it feature by feature through the full workflow (plan → execute → review → PR → merge gate) driven by /loop, an external orchestrator (see docs/workflow/ORCHESTRATION.md), or manual re-invocation, with no further questions. Features exhausted ≠ run over: an issue sweep then inventories open issues plus the run's own documented residue (known-issues, trade-offs, postponed findings), triages everything, and ships the fix-now issues through the same stages. Default: opens PRs, the human merges; --fullauto merges MERGE-READY PRs under non-negotiable safety floors. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your ag

Engineering-planning router for an already-designed feature. Given a feature whose SPEC product half is not marked `designed`, STOPS and redirects to `/design-feature <slug>` — no bypass flag. Given a designed feature, a GitHub issue #N (issue → scoped product half, satisfying capability closure), or an already-scoped slug/SPEC (straight to engineering-half scaffolding), routes to the right internal step, then ensures the roadmap entry and prints the next step. Force a path with flags to skip detection; `--next` plans the next `defined` feature from the roadmap. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "plan a feature", "plan the feature from issue N", "plan the next roadmap feature", "scaffold feature NN", "create SPEC and TASKS for NN".

Audit cross-document coherence: docs ↔ roadmap ↔ code ↔ fix index ↔ issues. Finds drift — features in docs/ not in the roadmap (or vice versa), fix-index entries already merged/closed, broken documentation-map links, dependency cycles, artifacts in the wrong language, naming-convention violations — and reports them ranked by severity, fixing only low-risk items on request. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "check doc consistency", "are the docs in sync", "audit the docs", "doc coherence review", "did the docs drift", "validate the roadmap".

Generate or update incremental developer documentation in the target project's own docs site: diff-driven how-to guides for what a unit of work changed, written through a discovered docs adapter (Starlight/Astro MDX is the first-class reference; plain markdown is the always-available fallback). Never a whole-project pass; never scaffolds a website; never edits source code. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "generate the docs", "update the docs site", "document this unit", "document what changed", "generate-docs".

Append a structured entry to the project's session log (`docs/LOGS.md`): what was done this session, files touched, decisions taken, and the next step — so the next session (or another person) can pick up the thread without re-reading git history. Run it before `/clear`, before closing Claude Code, or at any natural stopping point. On Claude Code and want hand-tuned per-skill model/effort tiers? Install the `#claude` branch instead (`npx skills add gtrabanco/agentic-workflow#claude`) — see the README. This branch is model-agnostic: the skill inherits whatever model and effort your agent session is already using. Triggers: "log this session", "log-session", "write a session log", "journal what we did", "record this session before I clear", "save the session summary".

Internal performance review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks the changed paths for algorithmic and resource regressions: N+1s, hot-path allocations, asset weight, and leaks. Findings only; never edits code.

Internal accessibility review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks the changed user-facing surface for accessibility: semantics, keyboard, focus, contrast, and ARIA correctness — applies only to user-facing surfaces. Findings only; never edits code.

Internal brand & copy review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks changed user-facing copy against the project's brand doc: voice, terminology, and honesty of claims — applies only to surfaces with user-facing text. Findings only; never edits code.

Internal correctness + simplification review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks correctness, error handling, duplication, dead code, and simplification opportunities against the project's own conventions. Findings only; never edits code.

Internal tech-debt review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Inventories shortcuts, duplication, stale abstractions and missing coverage on the changed surface, each with a re-trigger condition. Findings only; never edits code.

Internal UI/UX design review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks the changed UI against the project's design doc: consistency, states, responsiveness, and reuse — applies only when the project has a UI and the change touches it. Findings only; never edits code.

Internal security review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks secrets, input validation, injection, authn/authz, PII exposure, and dependency risk on the changed surface. Findings only; never edits code.

Internal SEO review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Checks changed web pages/routes for indexability, metadata, and structured data — applies only to public web surfaces. Findings only; never edits code.

Internal run-it verification review pass of the agentic-workflow review pack — composed in-turn by review-change and product-audit; not a menu entry. Runs the project's gate and the changed behavior for real — commands, exit codes, observed output — instead of assuming; what cannot be executed goes to the manual checklist. Findings only; never edits code.