Practical playbooks for coding agents

Modernizes legacy applications incrementally — strangler-fig slices, expand-contract data migrations, parity-verified cutovers, and clean decommissioning. Use when migrating a monolith or legacy stack, upgrading frameworks in place, extracting services, replatforming, or when the user mentions modernization, migration, or a legacy rewrite.

• legacy
• strangler-fig
• migration
• replatform
• cutover
• +5 more

Read skill →

Organizes code into domain modules (capabilities) instead of only technical layers; splits large files, keeps public vs internal boundaries, and reduces scattered domain logic. Use when restructuring a codebase, planning module layout, refactoring for maintainability, or when navigation and ownership by business capability are unclear.

• modularization
• module-boundaries
• refactoring
• code-structure

Read skill →

Builds a hard transform by constructing both directions — write the forward transform (A → B, e.g. a compiler), then deliberately build the inverse (B → A, e.g. a decompiler), and converge on correctness by round-tripping the pair against real inputs. Use when the goal is a compiler, transpiler, converter, encoder, or migration and "just write it forward" keeps drifting, or when the inverse itself is the actual deliverable.

• roundtrip
• decompiler
• compiler
• transpiler
• inverse-transform
• +5 more

Read skill →

Keeps repositories tidy and documentation aligned with the real implementation—structure, naming, dead code and temp artifacts, and root docs (README, SPEC, TODO, ARCHITECTURE). Use when the user asks for housekeeping, repo cleanup, doc sync, documentation alignment, hygiene, or maintaining spec-driven project files.

• docs
• cleanup
• doc-sync
• repository-hygiene

Read skill →

Reviews code with the CRAP score — Change Risk Anti-Patterns — where cyclomatic complexity and test coverage combine into one risk number per method (crap = comp²·(1−cov)³ + comp). Hunts complex-and-untested code, prescribes the cheapest fix first (cover it, then simplify it), and gates regressions in CI. Use when auditing a codebase for risky methods, when review says "too complex" or "untested", or when prioritizing where tests and refactors pay off most.

• crap
• complexity
• cyclomatic
• coverage
• change-risk
• +5 more

Read skill →

Roasts a codebase the way a static analyzer would — SonarQube-style sweep over bugs, vulnerabilities and hotspots, code smells, duplication, complexity, and test coverage — with every finding backed by a receipt (file:line), a severity, a one-line roast, and a concrete minimal fix. Use when the user asks to roast, audit, or critique code honestly, asks "what's wrong with this codebase", or wants findings a quality-gate tool would raise.

• critique
• roast
• anti-patterns
• over-engineering
• code-smells
• +5 more

Read skill →

Learns from a provided example and generates alike — extracts the exemplar's structure, vocabulary, conventions, and omissions into an explicit fingerprint, then produces new work that passes the same-author test. Use when the user gives a sample and asks for "like this", "same style", "follow this pattern", or supplies a file/template to copy the format of.

• example
• mimicry
• pattern
• convention
• style-matching
• +2 more

Read skill →

Removes hardcoding and overfitting by promoting special cases into data, parameters, and honest abstractions — at the right moment. Detects the smells (magic literals, one-case branches, single-fixture logic, "it works for the example"), generalizes the minimum that kills them, and stops before speculative generality. Use when code works for one input/instance/environment but must handle a family of them, when review says "hardcoded", or when a fix smells overfit to the bug report.

• generalization
• hardcode
• overfitting
• magic-numbers
• parameterize
• +5 more

Read skill →

Builds the user journey from a requirement first — actors, steps, states, and failure paths as an explicit map — then implements it as vertical end-to-end slices, one journey step per slice. Use when turning a requirement, PRD, or feature request into working software, when scope needs cutting, or when the user mentions user journeys, journey mapping, or walking a story end-to-end.

• user-journey
• requirements
• vertical-slice
• walking-skeleton
• scope
• +1 more

Read skill →

Guides lean, direct implementations by removing redundancy and dead code, avoiding unnecessary abstraction, and favoring readability over cleverness. Use when implementing features, refactoring, simplifying code, removing unused code, or when the user asks for minimal, maintainable, or proportionate solutions.

• lean-code
• simplicity
• dead-code
• readability

Read skill →

Decomposes a goal along three axes — hierarchical breakdown (goal → phases → subtasks), sequential ordering (must-finish-before), and parallel grouping (can-run-together) — into a single artifact that combines a WBS tree, a critical path, and parallel waves. Use when breaking a goal into work items, sequencing or parallelizing execution, or when the user mentions sub-tasks, parallel work, dependencies, sequencing, or WBS.

• wbs
• work-breakdown
• dependency-graph
• parallel
• sequencing
• +3 more

Read skill →

Wires UI to real application logic and exposes domain capabilities through clear interfaces; handles loading, success, and error states. Use when building or reviewing end-to-end features, removing placeholder UI, surfacing backend capabilities in the UI, connecting forms and APIs, or verifying integrated user flows.

• ui
• backend
• forms
• api

Read skill →

Runs a continuous improvement cycle — consult memory, complete the next TODO, test and build, harvest learnings back to memory, then research the competition. Use when maintaining a codebase over many agent sessions, when institutional knowledge keeps getting lost between sessions, or when progress needs a repeatable flywheel.

• dev-loop
• memory
• todo
• harvest
• continuous-improvement
• +1 more

Read skill →

Routes a task to the right skill in this library — a router over the full catalog, mapping the situation in front of you to the one skill (or skill chain) that fits. Use when starting a task and unsure which skill applies, when several skills seem relevant, when the user asks which skill to use, or when invoked as the entry point for installed Skillsheet skills.

• router
• discovery
• skill-selection
• meta
• catalog
• +1 more

Read skill →

Guards an autonomous loop against runaway token and time spend with daily caps, report-only mode, and kill-switches. Use when a loop runs unattended, when API costs must stay bounded, or when a cycle should degrade gracefully to reporting instead of acting.

• budget
• token-limits
• kill-switch
• cost-control
• guardrails

Read skill →

Enforces hard guardrails for autonomous loops — path denylists, push and merge rules, and escalation triggers loaded before any work begins. Use when a loop can edit files or push branches, when setting up agent automation, or whenever changes must stay inside explicit boundaries.

• guardrails
• denylist
• safety-policy
• push-rules
• escalation

Read skill →

Produces a clean, prioritized list of actionable work for an autonomous loop from CI failures, open issues, recent commits, and chat threads. Use when a development loop needs to decide what to work on next, when backlog noise exceeds signal, or at the start of each loop cycle.

• triage
• prioritization
• backlog
• ci-failures
• loop-cycle

Read skill →

Acts as the checker in a maker/checker split, rejecting work unless evidence is strong. Use when an autonomous loop or another agent produced a change that must be approved, when reviewing generated diffs for scope creep or test evasion, or when a pipeline needs a quality gate before commits land.

• maker-checker
• code-review
• quality-gate
• approval
• evidence

Read skill →

Fixes one specific problem with the smallest diff that could work — no drive-by refactors, no speculative abstraction. Use inside autonomous loops, when addressing a single CI failure or review comment, or whenever a small targeted change is safer than a broad one.

• minimal-diff
• surgical-change
• bug-fix
• scope-discipline
• scope-creep
• +1 more

Read skill →

Iterates code review until convergence — addressing every comment, re-requesting review, and stopping only when the diff is clean and approved. Use after opening a pull request, when review feedback arrives in batches, or when closing out comments one-by-one loses track of what remains.

• code-review
• pull-request
• iteration
• feedback
• convergence

Read skill →

Verifies processing, migration, and conversion through realistic end-to-end round-trip cases—fixture input, run pipeline, compare to explicit expected output, iterate until stable. Use when validating transforms preserve meaning/structure, when adding migration or format conversion confidence, or when the user mentions round-trip tests, golden files, E2E data processing, or compatibility regressions.

• round-trip
• golden-files
• e2e
• regression

Read skill →

Verifies implemented work with sufficient tests, runs the relevant suites after changes and fixes, and blocks completion until tests pass. Use when implementing features, fixing bugs, refactoring, or when the user asks to finish, ship, or mark work complete; also when tests are missing, failing, or need regression coverage.

• verification
• test-suites
• regression
• completion

Read skill →