A collection of reusable Claude Code skills for software engineering workflows. I adapted these skills from a specific project to be more generic and project-agnostic.
Claude Code skills are markdown instruction files that live in .claude/skills/ and teach Claude specific workflows. In this repo, the skills are in that standard location. When invoked (e.g., /investigate), Claude follows the skill's methodology — using subagents for parallel exploration, writing structured outputs, and chaining skills together.
| Category | Skills | What It Does |
|---|---|---|
| Architecture Lenses | 13 | Visualize your codebase from different perspectives using mermaid diagrams |
| Investigation | 3 | Deep codebase analysis, root cause finding, architectural immunity |
| Planning & Implementation | 6 | Requirements → plan → validate → implement pipeline |
| Auditing | 7 | Audit architecture, tests, bug patterns, AI-generated slop, and workflow friction |
| Documentation | 3 | Keep architecture docs and specs in sync with code |
Visualize your codebase from different architectural perspectives using mermaid diagrams. Each lens answers a specific question about your system. Use the vscode extension mermaid to see rendered mermaid plots within the markdown files.
| Skill | Lens | Question It Answers |
|---|---|---|
arch-lens-c4-container |
C4 Container | How is it built? |
arch-lens-process-flow |
Process Flow | How does it behave? |
arch-lens-data-lineage |
Data Lineage | Where is the data? |
arch-lens-module-dependency |
Module Dependency | How are modules coupled? |
arch-lens-concurrency |
Concurrency | How does parallelism work? |
arch-lens-error-resilience |
Error/Resilience | How are failures handled? |
arch-lens-repository-access |
Repository Access | How is data accessed? |
arch-lens-operational |
Operational | How is it run and monitored? |
arch-lens-security |
Security | Where are the trust boundaries? |
arch-lens-development |
Development | How is it built and tested? |
arch-lens-scenarios |
Scenarios | Do the components work together? |
arch-lens-state-lifecycle |
State Lifecycle | How is state corruption prevented? |
arch-lens-deployment |
Deployment | Where does it run? |
Use make-arch-diag to select the right lens interactively. Use verify-diag to validate a diagram's accuracy against the codebase.
The make-plan and rectify skills will automatically choose the most appropriate lens for visualizing the proposed changes to codebase.
See examples generated against UMI-tools (process-flow, data-lineage, module-dependency)
Skills for investigating bugs, making plans to address bugs, and researching best practices & patterns. The core flow is investigate a problem, then design a solution that solves the architecture rather than the bug. review-approach is an optional step you can run on a rectify plan or make-plan to research what modern solutions exist.
| Skill | Purpose | Trigger |
|---|---|---|
investigate |
Root cause analysis with parallel subagents | /investigate, paste an error traceback |
rectify |
Devise architectural immunity plans (not bandaid fixes) | /rectify after an investigation |
review-approach |
Research modern solutions via web search (optional) | /review-approach on any plan |
The core pipeline is make-plan → dry-walkthrough → implement-worktree. The make-scenarios & make-req skills are optional exploratory steps for when you're not yet sure what to build. elaborate-phase can be used when your plan is too large to implement in one go. It will make an independent plan for each phase.
┌──────────────────────────────────────────────────┐
(optional) (optional) │ Core Pipeline │
make-scenarios ──→ make-req ──────→ │ make-plan → dry-walkthrough → implement-worktree │
↑ └──────────────────────────────────────────────────┘
or use directly
make-scenarios helps when you don't yet know how to frame a problem or feature. You state a perspective (e.g., "I'm working on the authentication module for developers") and the skill explores the codebase to surface scenarios like "Developer doesn't want to get logged out mid-task." Those scenarios then guide requirement writing.
make-req takes scenarios (or any task description) and decomposes them into grouped, verifiable requirements. It can also be pointed at an entire repo to reverse-engineer the requirements that would be needed to generate the project from scratch.
Both are useful for refining what you need before planning. Neither is required — you can go straight to /make-plan if you already know what to build.
| Skill | Purpose | Trigger |
|---|---|---|
make-scenarios |
Discover "Actor wants to..." scenarios from a stated perspective | /make-scenarios |
make-req |
Decompose into grouped, verifiable requirements (REQ-GRP-NNN) | /make-req |
make-plan |
Create implementation plans with arch lens diagrams | /make-plan |
elaborate-phase |
Elaborate a single phase into a self-contained implementation plan | /elaborate-phase |
dry-walkthrough |
Validate a plan by tracing every change against the codebase | /dry-walkthrough |
implement-worktree |
Implement a plan in an isolated git worktree | /implement-worktree |
Audit codebases for architectural issues, test quality, bug patterns, and AI-generated slop. These should be tailored to your specific project.
| Skill | Purpose | Trigger |
|---|---|---|
audit-arch |
Audit architecture against standards and practices | /audit-arch |
audit-bugs |
Mine historical bug patterns from claude code project conversation logs | /audit-bugs |
audit-defense-standards |
Audit codebase against defense standards from bug patterns | /audit-defense-standards |
audit-tests |
Find useless tests, over-mocking, weak assertions | /audit-tests |
design-guards |
Design architectural guards for identified bug patterns | /design-guards |
id-slop |
Find AI-generated code slop (phase comments, dead code, compat hacks) | /id-slop |
audit-friction |
Mine session logs for repeated failures, stuck loops, and workflow friction | /audit-friction |
Keep architecture docs and specifications in sync with implementation. These should be tailored to your specific project.
| Skill | Purpose | Trigger |
|---|---|---|
update-architecture |
Rebuild architecture docs from code understanding (8-file structure) | /update-architecture |
update-specs |
Maintain append-only functional specifications (SPEC-NNN) | /update-specs |
mermaid |
Standard mermaid diagram styling and conventions | /mermaid |
Many skills are designed to chain. Here are common workflows:
Bug discovered → architectural fix:
/investigate → /rectify → /dry-walkthrough → /implement-worktree
↑
(optional: /review-approach on the rectify plan)
New feature → shipped:
/make-plan → /dry-walkthrough → /implement-worktree
↑
(optional: /make-scenarios → /make-req to clarify what to build)
(optional: /review-approach on the plan)
(optional: /elaborate-phase on the plan to split into smaller independent plans)
Codebase health check → fixes:
/audit-arch + /audit-tests + /id-slop → /make-plan → /dry-walkthrough → /implement-worktree
To install for a specific project, open a terminal in your project folder and run:
git clone https://github.com/Trecek/useful-claude-skills.git /tmp/claude-skills && \
mkdir -p .claude/skills && \
cp -r /tmp/claude-skills/.claude/skills/* .claude/skills/ && \
rm -rf /tmp/claude-skillsTo install globally (available in all projects):
git clone https://github.com/Trecek/useful-claude-skills.git /tmp/claude-skills && \
mkdir -p ~/.claude/skills && \
cp -r /tmp/claude-skills/.claude/skills/* ~/.claude/skills/ && \
rm -rf /tmp/claude-skillsTo install a single skill (e.g., investigate):
git clone --depth 1 https://github.com/Trecek/useful-claude-skills.git /tmp/claude-skills && \
mkdir -p .claude/skills/investigate && \
cp /tmp/claude-skills/.claude/skills/investigate/SKILL.md .claude/skills/investigate/ && \
rm -rf /tmp/claude-skills