fff

Plugin fff from marketplace ffflow in zerotechdebt/ffflow. Commands read from the repo's manifest — 28 days ago.

Skills (38)

• adopt-ffflow

  End-to-end onboarding for a new FFFlow project. Runs init-ffflow, stack-init, then hands off to plan-roadmap to phase out the work (greenfield or brownfield — roadmap figures out the right per-phase entry point). Use `--ui` to adopt FFFlow's view-layer-purity structure (the frontend sibling of hexag

• audit

  Run the FFFlow keep-honest auditors against this project. Coordinator with per-type cartridges (CLAUDE.md freshness, spec drift, characterization tests, architecture conformance, complexity/refactor signals, and L3 RID traceability). Use --type to target one; --plan to convert findings into work.

• autopilot

  Meta-skill that wraps any interactive skill for unattended execution. Reads project context to stand in for the user on routine decisions, with a decision log.

• characterize

  For an unspec'd codebase, walk it module-by-module to extract an evergreen spec (committed immediately) and produce a plan for characterization-test backfill.

• ci-gates

  GitHub Actions workflow templates for FFFlow projects — runs level-appropriate audits and quality gates as PR checks.

• component-driven-ui

  View-layer purity — presentational vs. connected components, the atoms→molecules→organisms→layouts ladder, story-as-vignette doctrine, design tokens, and the decompose→story→test→integrate ordering. The frontend sibling of hexagonal-architecture. L1+ reference rulebook.

• contract-enforcement

  Mocks must be anchored to verifiable contracts — typed mocks against ports, adapter tests on the same interface, OpenAPI schema generation, consumer-driven contracts. L2+ reference rulebook.

• debugging

  Hypothesis-driven debugging — reproduce, gather evidence, test hypotheses, find root cause, fix minimally, then close the spec gap.

• defect-driven-specification

  Every bug becomes a spec before it becomes a fix — the defect-driven loop with @known-defect, @accepted-risk, @unverified-intent annotations. L1+ reference rulebook.

• git-hooks

  Pre-commit and pre-push hooks that call justfile recipes. Level-aware: pre-commit is fast; pre-push runs the level's gates.

• hemingway

  Ruthless concision for prompts and documentation — cut 30-50% of words, every sentence earns its place

• hexagonal-architecture

  Domain / Application / Infrastructure layers — ports, adapters, the dependency rule, and how layers map to spec types and test strategies. L1+ reference rulebook.

• init-ffflow

  Bootstrap a project for FFFlow — write .ffflow/config.yaml, stamp the beliefs block into the root CLAUDE.md, propose level/stack/capture. Idempotent.

• justfile

  Justfile interface and maturity model for FFFlow — baseline recipes every project implements (test, lint, format, check-all, etc.) plus tier cartridges (Tier 1 quality, Tier 2 security, Tier 3 advanced, Tier 4 polyglot orchestration).

• notetoself

  Session-context handoff — /notetoself save persists current state to /tmp; /notetoself resume reads it back. Isolated by working directory.

• plan-breakdown

  Cut a sealed plan into independently shippable chess moves — each task is a spec slice with explicit scope, dependencies, and acceptance criteria.

• plan-capture

  Capture a sealed plan as durable work. Two layers: roadmap rationale committed to docs/roadmap/<slug>/ in the repo (always, regardless of backend), and tasks pushed to the configured issue tracker (cartridges for github-issues, linear, jira, or markdown). Bidirectional traceability between repo and

• plan-chat

  Interactive design of a behavior change — produces a plan describing the path from current spec to target spec, adapted to project level (L0–L3). Resolves every decision before sealing.

• plan-roadmap

  Phase-level planning above plan-chat. Reads a vision doc (project.md, README, free-form prompt) or an in-progress codebase and produces an ordered, dependency-aware roadmap of independently shippable phases. Each phase becomes a /plan-chat (or /characterize, or /audit --plan, or recursively another

• plan-status

  Show in-flight plans for this project — phase, what's done, what's next. Reads from /tmp/ffflow-plans/<project-hash>/.

• quality-gates

  The four-gate model (Structure, Correctness, Coverage, Maintainability) with spec liveness, mutation testing, complexity budgets. L3 reference rulebook.

• refactor

  Coverage/complexity-driven refactoring. Identify targets, refactor under green tests. Generates plan tasks rather than ad-hoc edits.

• rid-traceability

  Requirement ID format, assignment, uniqueness, and audit enforcement — the traceability backbone of FFFlow. L3 reference rulebook.

• self-review

  Pre-PR self-review checklist — spec correctness, implementation quality, test coverage, audit pass. Level-aware.

• spec-first-development

  The steady-state development loop — spec change drives implementation, producing both step definitions and unit tests. L2+ reference rulebook.

• stack-assess

  Compare the current project to its declared stack and level — identify missing tools, version mismatches, configuration gaps, level upgrade readiness.

• stack-init

  Bootstrap a stack into a project — install deps, write configs, justfile, git hooks, CI. Level-aware, idempotent, non-destructive on existing projects.

• stack

  FFFlow stack toolchain reference — dimensions (package manager, formatter, linter, test runner, coverage, mutation testing) and level-aware defaults. Cartridges for python, typescript, typescript-ui, java, rust, and polyglot.

• tdd-loop

  The red/green/refactor discipline — same at every level, artifacts scale. Reference rulebook loaded by work and by characterize backfill tasks.

• total-specification

  The FFFlow methodology — 10 pillars of spec-driven development with dual coverage, property-based testing, mutation testing, and full RID traceability. L3 reference rulebook.

• upgrade-ffflow

  Reconcile this project against the current FFFlow version. Reads the stamped ffflow_version, walks the migration ledger, duck-types unstamped repos by evidence, applies the gaps, re-stamps. Run after updating the plugin.

• work-epic

  Sequential execution of every open issue under an epic onto one feature branch — one squashed commit per task, one PR per epic. Implement and review subagents kept independent; user approves the merge.

• work-fanout

  Parallel execution of multiple chess moves across worktrees. Spawns N subagents, each runs work in isolation, with stall detection and resume awareness.

• work-issue

  Execute one captured issue from cold-start to merged PR. Spec updates ship in the same PR. Level-aware: lint+test gates at L0, full quality gates at L3. For parallel multi-issue runs use work-fanout; for one PR per epic use work-epic.

• worktrees

  Isolated worktree management for parallel work — naming convention, creation, cleanup, troubleshooting.

• writing-specs

  Gherkin 6 conventions for FFFlow — Feature structure, Rule blocks, Scenario Outlines, spec types by layer, property-based specs. L2+ reference rulebook.

• yagni

  Review-time discipline — only build what you need. Provides the TODO-with-trigger format that bridges "fix now" (zero-tech-debt) and "we'll get to it" (the smell). Triggers must be concrete inflection points, not vague intentions. Tension partner with zero-tech-debt.

• zero-tech-debt

  Review-time discipline — when you notice a minor issue, fix it now if it's <15 min and uncontroversial. Never "we'll get to it" without a code-level marker. Pair with yagni for the deferral cases. Loaded by code-review, self-review, work-issue, refactor, and audit.

Similar plugins