Planning & Workflow

Fetch GitHub issues, fix them with sub-agents, open PRs and handle review comments

Harden a plan by being interviewed one question at a time before coding

Harden a plan through interview questions while updating living project docs

Archive and deliver a completed Classic workflow change

Plan, implement and accept Classic workflow tasks, including repair passes

Write the Classic technical design and get user confirmation before building

Repair a localized defect through the Classic hotfix preset

Open a Classic change, clarify requirements and get user confirmation

Commit, push or merge a scoped change without touching unrelated dirty files

Make a lightweight adjustment within one change using the Classic preset

Choose how to merge, open a PR or clean up once all tests pass

Question a plan or design relentlessly until the shared understanding is clear

Run grill, to-spec, to-tickets and implement skills in order with real tests

Implement the tasks of an OpenSpec change one step at a time

Archive a finished OpenSpec change once implementation is complete

Archive several completed OpenSpec changes in one pass

Walk through a full OpenSpec cycle on real code with guided steps

Check that an implementation matches its change artifacts before archiving

Write the failing test before any feature or bugfix implementation code

Apply the commit message rules to follow before making any git commit

Build a new project slice through its checks until the user journey works

Add one bounded feature to an existing app without changing current behavior

Write an MVP technical design with architecture choices and tradeoffs

Pick the right planning, build or debugging workflow for an app project

Build a single-file HTML acceptance demo to check criteria before shipping

Create and update Plans.md task plans and track progress against them

Generate a single-file HTML plan brief to review scope and risks before coding

Render an HTML progress tracker for task status, cost and drift alerts

Sync Plans.md with the implementation and detect drift from the plan

Archive bloated Plans.md, session logs and old state files to keep them lean

Turn raw notes, logs or screenshots into structured GitHub issue reports

Redact and file GitHub bug reports for the chengfeng-videocut editing tool

Build better engineering habits: feedback loops, DRY knowledge and automation

Set up isolated git worktrees for feature work before implementation plans

Work through requirements, design, coding, review and bug fixes in five steps

Sketch types, signatures and module layout before coding, then fill them in

Run parallel candidate attempts, pick a base and graft the best parts together

Build an auditable plan for big migrations with logged decisions and checks

Test the shared premise directly after two fixes fail the same check

Build a script or codemod for repetitive edits instead of doing them by hand

Turn repeated corrections into lints, flags or scripts instead of more text

Build two or three competing prototypes before committing to a new design

Choose core types and data structures before writing logic that uses them

Model stateful logic explicitly so branching and shape assumptions stay simple

Converge on the target architecture instead of keeping throwaway compatibility code

Rethink an existing design from first principles when new requirements arrive

Split multi-step work into small verifiable commits and PRs a reviewer can follow

Write a failing regression test first when the bug has a cheap local target

Build a shared domain glossary and bounded contexts before writing code