claudeskills.page

22 skills · category

Engineering Workflow skills for Claude Code

Skills that shape how Claude works rather than what it builds: reproducing bugs before patching them, test-driven loops, atomic commits, pull requests reviewers can approve, safe refactors, dependency upgrades, git history repair, and onboarding into an unfamiliar codebase.

Download all 22 (.zip) Browse the list
  1. 025Code Archaeology
  2. 026Code Review
  3. 027Code Search
  4. 028Codebase Onboarding
  5. 029Codemods
  6. 030Commit Craft
  7. 031Dead Code Removal
  8. 032Dependency Upgrades
  9. 033Git History Surgery
  10. 034Issue Triage
  11. 035Legacy Code Rescue
  12. 036Migration Planning
  13. 037Monorepo Navigation
  14. 038Pull Request Writer
  15. 039Release Management
  16. 040Requirements Clarification
  17. 041Review Feedback Resolution
  18. 042Safe Refactoring
  19. 043Systematic Debugging
  20. 044TDD Loop
  21. 045Technical Spike
  22. 046Work Estimation

Every engineering workflow skill

Each card opens the full playbook, example prompts and install commands.

No. 025

Code Archaeology

Learn why code exists before you delete it

Claude finds the commit that actually introduced a behavior, not the last formatter run, using blame that ignores whitespace and moves plus pickaxe and line-range history. It reads the PR discussion, linked issues and ADRs, quotes the original reason, checks whether that reason still holds against today's code, dependencies and data, and ends with a provenance note and a recommendation backed by evidence.

code-archaeology 136 lines
★ No. 026

Code Review

Findings ranked by severity, minus the nitpicks

Gives Claude a two-pass review method for teammates' diffs: first design and correctness traced with concrete adversarial inputs, then a sweep for auth gaps, injection, races, unsafe migrations, N+1 queries, and weak tests. Findings are verified before posting, labeled blocker through nit, carry a file and line plus a fix, and end with a verdict that states what was not reviewed.

code-review 204 lines · 2 files
No. 027

Code Search

Find every usage, and prove you found them all

Claude picks the right search tool for the question, from ripgrep with types, globs and word boundaries to ast-grep for call shapes, git grep for history and LSP for type-aware references. It searches every spelling, includes config, templates, SQL and infra, follows re-exports and dynamic access, cross-checks counts, and reports results with file and line evidence plus an explanation of false positives.

code-search 150 lines
No. 028

Codebase Onboarding

From git clone to a verified map in one session

Instead of summarizing files at random, Claude classifies the repo, runs a bundled map script for languages, manifests, CI and entry points, proves the build and test commands work, and traces one real flow from handler to database with file and line references. The result is a one-page architecture note with run instructions, a module map, hotspots, and open questions.

codebase-onboarding 213 lines · 2 files
No. 029

Codemods

Hundreds of call sites changed, tested, and accounted for

Claude inventories every shape of the target pattern, runs official codemods first, then writes a narrow transform in the right tool with before, after and must-not-change fixtures. Dry-run diffs are reviewed on a sample covering all shapes, changes land in reviewable batches with the full test gate, a residue scan explains every leftover site, and a lint rule stops the old pattern returning.

codemods 144 lines · 2 files
No. 030

Commit Craft

Commits that bisect cleanly and explain why

Turns a messy working tree into a short series of atomic commits: refactors before features, tests alongside the behavior they cover, and Conventional Commits headers whose bodies explain the reason, not the diff. Claude stages hunk by hunk, tests the staged snapshot, folds review corrections in with fixup commits, and can lint every message in a range with a bundled script.

commit-craft 218 lines · 2 files
No. 031

Dead Code Removal

Delete unused code with two kinds of proof

Claude configures the right analyzer for the stack with real entry points, triages candidates against known false-positive patterns such as dynamic imports, framework conventions and external callers, and requires a second signal like search, coverage or runtime logs before deleting. Removals land in small batches by kind with the full build and test gate after each, and confirmed false positives go into analyzer config.

dead-code-removal 142 lines
No. 032

Dependency Upgrades

Major version bumps without the Friday surprise

Claude upgrades in risk groups instead of bumping everything at once: a green baseline first, patch and minor updates batched, each major handled alone with its migration guide turned into a checklist, official codemods committed separately, and the lockfile changed only where intended. It also sets Renovate or Dependabot policies so routine updates merge themselves and majors wait for a plan.

dependency-upgrades 202 lines
No. 033

Git History Surgery

Rewrite history with a backup ref and a tree diff

Claude treats every history rewrite as surgery: backup branch first, clean tree, the right tool for the goal, and a tree diff against the backup to prove nothing was lost. It squashes, splits, reorders, and moves commits, resolves rebase conflicts with zdiff3 context, recovers work from the reflog, and asks before any force push or reset on a branch others use.

git-history-surgery 178 lines · 2 files
No. 034

Issue Triage

Every issue leaves triage with one clear state

Claude runs each issue through a fixed decision flow: actionable here, duplicate, enough information, reproducible, then type, severity, area and owner. Duplicates are found by error text rather than titles, missing-info requests name the exact facts needed, reproduction is time-boxed, and bulk label and close changes are shown as a table for confirmation before anything is applied.

issue-triage 188 lines
No. 035

Legacy Code Rescue

Change untested code without breaking production

When code has no tests, Claude stops guessing and follows Feathers-style technique: rank hotspots by churn times size, find test points, break dependencies at seams with minimal mechanical edits, and pin current behavior with characterization or golden-master tests. New behavior is sprouted into fresh tested units, and larger modernization happens in strangler-fig slices, never a big-bang rewrite.

legacy-code-rescue 177 lines · 2 files
No. 036

Migration Planning

Phased migrations that ship, roll back, and finish

Claude plans migrations so they finish: a quantified why, a machine-readable inventory that becomes the burn-down, a strategy with a named seam, and phases that each ship to production with numeric exit criteria and a rehearsed rollback. Shadow comparisons and data reconciliation guard correctness, CI blocks new use of the old path, and the plan carries a dated step that deletes the old system.

migration-planning 142 lines
No. 037

Monorepo Navigation

Run the affected tasks, not the whole repo

Claude identifies the workspace tooling first, then runs only the affected tasks through Turborepo, Nx, or pnpm filters instead of testing everything from the root. It adds dependencies to the package that imports them, uses the workspace protocol for internal packages, respects module boundaries, and debugs cache misses by inspecting task hashes, inputs and declared outputs.

monorepo-navigation 156 lines
No. 038

Pull Request Writer

PRs a reviewer can approve in one sitting

Claude reads the real three-dot diff before writing, then produces a PR title that works as a squash commit and a description covering motivation, a suggested review order, test commands it actually ran, screenshots for UI, and risk, rollout and rollback notes. Oversized branches get split or stacked along clean seams, with gh CLI commands to create and update each PR.

pull-request-writer 185 lines
No. 039

Release Management

Version numbers that tell consumers the truth

Claude derives the next version from the actual changes rather than gut feel, cuts annotated tags that CI builds and publishes from, and picks fitting automation such as release-please, semantic-release, Changesets or git-cliff. Release branches and hotfixes follow a fix-on-main-then-cherry-pick flow, and every push or publish waits for your confirmation behind a pre- and post-release checklist.

release-management 202 lines
No. 040

Requirements Clarification

Five sharp questions before five days of wrong work

Before building on a vague request, Claude researches what the code, tickets and docs already answer, ranks the remaining unknowns by cost of being wrong, and asks one batch of questions with recommended defaults. The result is a one-page brief with testable acceptance criteria, scope, non-goals and an assumptions log the user confirms before any planning or code.

requirements-clarification 148 lines
No. 041

Review Feedback Resolution

Every review thread closed with a commit or a reason

Claude pulls every unresolved review thread through the GitHub GraphQL API and turns it into a checklist, reads all feedback before editing, and classifies each item as blocking, question, suggestion, nit or out of scope. Fixes land in focused commits with tests, each thread gets a reply with a commit SHA or evidence, settled threads are resolved, and the reviewer receives one summary with a re-request.

review-feedback-resolution 154 lines · 2 files
No. 042

Safe Refactoring

Change the structure, prove the behavior did not

Keeps Claude from bundling rewrites with behavior changes. It pins current behavior with characterization or golden-master tests, plans the work as named refactorings, runs tests and commits after each small step, prefers scope-aware tools over text replace, and uses parallel change for public interfaces. Suspected bugs get logged and pinned, not silently fixed mid-refactor.

safe-refactoring 185 lines
★ No. 043

Systematic Debugging

Root causes, not lucky patches

Stops Claude from guessing at fixes. It reproduces the failure first, narrows the search with git bisect or input reduction, tests ranked hypotheses one variable at a time, and only then changes code. Every fix ends with a regression test that fails without it and a short root-cause note you can paste into the PR.

systematic-debugging 156 lines · 2 files
No. 044

TDD Loop

See it fail, make it pass, then clean it up

Makes Claude work test-first for real: it writes a test list, runs every new test to confirm it fails on the assertion rather than a typo, writes the least code to pass, and refactors only on green. It picks the next test deliberately, checks coverage on touched files, and sabotages key code paths to prove the tests can actually catch regressions.

tdd-loop 192 lines
No. 045

Technical Spike

Answer one hard question inside a time box

Claude runs investigations the way a senior engineer would: one sharp question, criteria and thresholds set before testing, a fixed time box, and a throwaway prototype aimed at the riskiest assumption first. Findings come back as a decision memo that leads with a recommendation and confidence level, backed by reproducible benchmarks, cited docs, and named unknowns.

technical-spike 176 lines
No. 046

Work Estimation

Ranges with confidence levels, not wishful dates

Claude reads the code that will change, breaks the feature into half-day to three-day tasks including review, rollout and docs, and turns big unknowns into spikes instead of padded guesses. Three-point estimates feed a bundled Monte Carlo script that reports P50, P80 and P90 totals plus the tasks driving the most uncertainty, then converts effort into calendar time with stated assumptions.

work-estimation 198 lines · 2 files

Choosing Engineering Workflow skills

Install the skills that match requests you make every week; each costs about 100 tokens of standing context until it loads. If you are not sure where to begin, start with Code Review and Systematic Debugging. For background, read The Best Claude Code Skills in 2026, by Use Case, How to Share Claude Code Skills With Your Team and Personal vs Project Skills.

By technology: Git skillsJavaScript skillsGitHub Actions skillsPython skillsRust skills

Install several

Install several at once

The installer accepts any number of skill names. Add --project to install into the current repository.

curl -fsSL https://claudeskills.page/install.sh | sh -s -- code-archaeology code-review code-search codebase-onboarding codemods commit-craft dead-code-removal dependency-upgrades git-history-surgery issue-triage legacy-code-rescue migration-planning monorepo-navigation pull-request-writer release-management requirements-clarification review-feedback-resolution safe-refactoring systematic-debugging tdd-loop technical-spike work-estimation

Engineering Workflow skills FAQ

How do I install every Engineering Workflow skill at once?

Download the bundle at https://claudeskills.page/downloads/category/workflow.zip and unzip it into ~/.claude/skills/ (or .claude/skills/ inside a repository). To pick a few, pass several names to the installer: curl -fsSL https://claudeskills.page/install.sh | sh -s -- code-archaeology code-review code-search.

Will installing 22 skills slow Claude Code down?

No. Claude Code keeps only each skill's short description in context — roughly 100 tokens per skill — and loads the full instructions only when a request matches. Install the whole category if it fits your work; unused skills cost almost nothing.

Which Engineering Workflow skill should I start with?

Start with Code Review, Systematic Debugging. They cover the most common requests in this category; add the rest as your work calls for them.

Featured in The Starter Pack, Testing & Quality.

Explore other categories

esc