obra

writing-skills

Create, revise, and validate AI skills before deployment.

test-driven-development

Implement features and fixes by writing tests before production code.

verification-before-completion

Verify results before claiming work is complete, fixed, or passing.

subagent-driven-development

Execute implementation plans by splitting and advancing independent tasks in-session.

brainstorming

Clarify intent, requirements, and solution direction before any creative implementation work.

using-superpowers

Set conversation rules to discover and invoke skills before replying.

writing-plans

Turn requirements into a clear step-by-step execution plan before implementation.

finishing-a-development-branch

Helps decide merge, PR, or cleanup steps after branch work is complete.

systematic-debugging

Systematically investigate bugs, test failures, and unexpected behavior before fixing.

using-git-worktrees

Create isolated workspaces for feature development without disturbing current code.

MCP

★397

private-journal

Privately journal thoughts and quickly retrieve insights with semantic search.

—Get→

Testing Skills With Subagents

Iteratively test process documentation to find gaps and refine instructions.

Test-Driven Development (TDD)

Use test-first development to improve code quality and maintainability.

Commenting Intent

Helps developers write code comments explaining intent, rationale, and key tradeoffs.

Reducing Complexity

Helps users reduce software complexity for better maintainability and delivery speed.

Keeping Routines Focused

Helps you spot multi-purpose routines and refactor them into single-responsibility units.

Localizing Variables

Help developers limit variable scope to improve code clarity and maintainability.

Validating Inputs

Validate external inputs to prevent errors, failures, and security issues.

Dispatching Parallel Agents

Dispatch multiple agents in parallel to investigate and fix independent issues.

Finishing a Development Branch

Helps developers finish a branch with merge, PR, or cleanup workflows.

Code Review Reception

Helps developers handle code review feedback with rigor, judgment, and effective responses.

Subagent-Driven Development

Execute implementation plans with task-specific subagents and code review checkpoints.

Requesting Code Review

Trigger a code review against plans or requirements before moving forward.

Using Git Worktrees

Create isolated Git worktrees safely with smart directory selection.

Systematic Debugging

Debug issues with a four-phase method that finds root causes before fixes.

Verification Before Completion

Run verification checks before completion to ensure results are truly correct.

Getting Started with Skills

Learn core Skills workflows, search patterns, and brainstorming use cases quickly.

Gardening Skills Wiki

Check a skills wiki for links, naming, cross-references, and coverage gaps.

Condition-Based Waiting

Replace fixed delays with condition polling for more reliable async tests.

Testing Anti-Patterns

Helps developers avoid common testing anti-patterns and write more reliable tests.

Single Purpose Variables

Improve code clarity and maintainability by assigning each variable one purpose.

Executing Plans

Execute detailed plans in batches with review checkpoints and course correction.

Defense-in-Depth Validation

Design layered validation across data flows to prevent bugs and security issues.

Simplifying Control Flow

Help developers simplify nested conditionals for clearer, more maintainable code.

Domain-Focused Naming

Name code by domain meaning to improve clarity and team alignment.

Writing Evergreen Comments

Write evergreen comments focused on what and why, not historical context.

Exploring Alternatives

Compare 2-3 approaches before execution to choose a stronger solution.

Designing Before Coding

Plan with pseudocode first, refine approaches, then translate into working code.

Remembering Conversations

Search past Claude Code chats to recover facts, decisions, and context.

Encapsulating Complexity

Design systems by hiding implementation details behind domain-level interfaces.

Maintaining Consistent Abstractions

Helps developers keep class abstractions cohesive and free of unrelated responsibilities.

Writing Plans

Create step-by-step implementation plans for engineers new to a codebase.

Root Cause Tracing

Trace bugs backward through call stacks to find the original trigger.

Creating Skills

Create process documentation with test-driven validation before finalizing the draft.

Naming Variables

Choose clear, accurate variable names that improve code readability and maintenance.

developing-claude-code-plugins

Build, update, test, and release Claude Code plugins efficiently end to end.

finding-duplicate-functions

Audit codebases to find semantically duplicate functions with different names or implementations.

writing-clearly-and-concisely

Rewrite reader-facing text to be clearer, tighter, and more professional.

remembering-conversations

Search past conversations before answering to recover context and avoid wrong assumptions.

working-with-claude-code

Get official guidance for Claude Code CLI, MCP, plugins, and configuration.

using-tmux-for-interactive-commands

Run interactive CLI sessions safely via tmux for editors, REPLs, and Git flows.

mcp-cli

Use MCP services on demand via CLI without preloading extra context.

requesting-code-review

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

dispatching-parallel-agents

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

executing-plans

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Installing Skills System

Fork, clone to ~/.clank, run installer, edit CLAUDE.md

Brainstorming Ideas Into Designs

Interactive idea refinement using Socratic method to develop fully-formed designs

Refactoring Safely

Refactor with tests first, one change at a time, never mix refactoring with bug fixes or new features