Skip to content
Skills Library
Programming · Planning

feature-flow

/feature-flow

My default workflow for non-trivial features at work — understand read-only → plan mode + grill me on six fork categories → implement per approved plan → verify honestly. Use when starting any feature or non-trivial change in one of my work repos, when a prompt contains a GOAL/START FROM/FORKS block, or when I invoke /feature-flow.

Repository
skills ↗
Licence
MIT
Last repository change
12.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

My default workflow for non-trivial features at work — understand read-only → plan mode + grill me on six fork categories → implement per approved plan → verify honestly. Use when starting any feature or non-trivial change in one of my work repos, when a prompt contains a GOAL/START FROM/FORKS block, or when I invoke /feature-flow.

Original author description

My default workflow for non-trivial features at work — understand read-only → plan mode + grill me on six fork categories → implement per approved plan → verify honestly. Use when starting any feature or non-trivial change in one of my work repos, when a prompt contains a GOAL/START FROM/FORKS block, or when I invoke /feature-flow.

How it works

  1. Input contract
  2. Phase 1 — Understand (read-only)
  3. Phase 2 — Plan mode + grill
  4. Phase 3 — Implement
  5. Phase 4 — Verify
  6. Hard constraints (all phases)
Original SKILL.md headings · 69 lines, 862 words
SKILL.md preview
---
name: feature-flow
description: My default workflow for non-trivial features at work — understand read-only → plan mode + grill me on six fork categories → implement per approved plan → verify honestly. Use when starting any feature or non-trivial change in one of my work repos, when a prompt contains a GOAL/START FROM/FORKS block, or when I invoke /feature-flow.
---

# Feature flow

> Understand first. Grill me second. Code third. Verify honestly.

Agents given a feature request tend to sprint: they skim two files, pick the first plausible architecture, and start writing. On my work repos that fails predictably — the pipeline has infra I didn't mention, the decision they guessed was mine to make (cost, prod behavior), and the "obvious" pattern contradicts the peer repo we mirror. This skill is the antidote: a fixed four-phase order where coding is phase three, not phase one.

## Input contract

I invoke this with up to three blocks. Only GOAL is required:

- **GOAL** — what to add/change, current vs. desired behavior, who wants it. May include a role hint ("for the console work, act as a Senior UI Engineer").
- **START FROM** — anchors: `file.ts:line` pointers, entrypoints, the pattern to mirror, memory names to recall.
- **FORKS** — decisions where I already have a lean, stated inline ("I lean detail-only, YAGNI").

If START FROM is missing, do NOT free-explore: derive candidate anchors from the repo (entrypoints, routes, the closest existing feature) and confirm them with me before deep exploration. "Don't assume" applies to anchors too.

## Phase 1 — Understand (read-only)

Read every repo and infra surface the feature touches before proposing anything. No writes, no scaffolding, no "while I'm here" edits.

- Start from the anchors. Follow them outward: entrypoints → libs → schemas → auth → audit.
- Identify **the pattern to mirror** — the peer repo or existing feature that already does the closest thing (e.g. a sibling API's route/job shapes, an existing flow in the same domain). This single anchor outweighs any convention list.
- Recall memories matching the repos touched — both the ones I named and any others whose names match the repo/domain. Verify a memory's claims against the current code before relying on it.
- Note what you could NOT verify (env/creds visible only in cluster pods, manifests you can't read). These become questions, not assumptions.

## Phase 2 — Plan mode + grill

Enter plan mode. Before writing any plan, walk this fork checklist and resolve every applicable fork WITH me — including forks I didn't list but the checklist surfaces:

1. **Placement / sync-vs-async** — where does the work run? Enumerate 2–3 real options (in-process job, trigger existing infra, bounded inline).
2. **Trigger surface & feedback** — endpoint only? UI affordance? What does the operator actually see (toast, status panel, auto-refresh)?
3. **Scope** — exactly which slice of the pipeline/data is in; name what is explicitly OUT.
4. **Concurrency / consistency** — overlap with cron jobs, double-clicks, locking, idempotency.
5. **Cost & safety** — DRY_RUN / since-date knobs, LLM token spend, and explicit confirmation of prod behavior. Never assume spending money in prod is fine.
6. **Auth scope + audit + persistence** — reuse an existing scope or override (a semantic read behind a POST may deserve Read); is an audit event signal or noise; persist a run record or fire-and-forget.

Rules of the grill:

- Ask via AskUserQuestion when the tool is available; otherwise ask the same questions as plain numbered options in chat. The checklist is the essential part, not the tool.
- Every fork gets **a recommended option with a one-line why**. I veto cheaply; I don't want an open-ended survey.
- Respect my stated leans from the FORKS block — challenge them only with evidence from phase 1.
- Cost, prod behavior, and infra shape are genuinely MINE. Ask, don't assume — even if the answer seems obvious.
- Then present a short plan (not an essay) mapping each fork to its resolution, and get explicit approval before any code.

## Phase 3 — Implement

Per the approved plan, following repo conventions:

- Keep it simple and elegant. YAGNI: no speculative guards or validation a caller already enforces; no "future-proofing".
- Fixed business rules are constants, not new env knobs.
- LLM is Anthropic-only. Mirror the named pattern exactly — route shape, schema style, error consts, audit events.
- Rationale goes in memory / CONTEXT / ADR, never inline "why" comments.
- Tests: every test name starts with "should". Backend: vitest + testcontainers. Frontend: vitest + @testing-library/react.
- Frontend work is Senior-UI-Engineer grade: honest loading/disabled/error states (sonner for failures), abort in-flight requests on unmount/context-switch, keyboard + a11y on new affordances, no double-fire on re-render (hasRequested ref pattern).
- SQL changes → regenerate pgtyped against a throwaway Postgres on **:5433** (k9s shadows :5432 — see the pgtyped-regen memory), never the cluster DB. Migrations via node-pg-migrate.

## Phase 4 — Verify

- Backend: vitest full suite + tsc + eslint + prettier.
- Frontend (if touched): vitest + tsc + eslint.
- Report results honestly: failures with their output, skipped checks named as skipped. No "should pass".

## Hard constraints (all phases)

- Do NOT commit or push unless I explicitly approve. I usually commit myself.
- Do NOT kubectl / port-forward on your own initiative — ask me to open a tunnel or paste manifests/output.
- If a decision is genuinely mine — cost, prod behavior, infra shape — ask. A wrong guess in prod costs more than a question.

Versions

The database has no other skills named feature-flow.

Database snapshot: 13.11.2026 · package version baa919099851 (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

  • 90plan-feature
    The Explore to Plan to Code to Commit workflow for any non-trivial change. Forces understanding and an explicit plan before edits, with a one-sentence skip heuristic for trivial work. Use when starting a feature, a refactor, or any change whose steps are not obvious. Pairs with plan mode.
  • 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…
  • 100implement-feature
    End-to-end feature implementation workflow. Use when the user says "implement", "build feature", "work on task", "start implementation", or any feature development work. Covers plan review, test writing, implementation, verification, and delivery.
  • 95spine
    Orchestrates a gated, evidence-first engineering run. Classifies the task, routes it through intent, spec, plan, implement, and review with cross-provider agents, enforces artifact gates, and renders a fixed summary block. Entry points intent, adopt, implement, review, status,…
  • 90dev-flow
    This skill should be used when the user asks to "start work on a feature", "fix this bug", "implement this ticket", or "work on this regression". Standard development flow for any code change — feature path (design interrogation, falsify, plan, worktree, build, verify, ship) or…
  • 100david-workflow
    End-to-end workflow for a feature, fix or change. Plan in phases with a verification plan up front, implement, verify for real and review with sub agents, open a PR (or a gh stack) with evidence attached, drive CI and review comments to green, test on a preview deploy with a…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.