@obra
Covers backend, AI engineering, and product — featuring brainstorming, using-superpowers, systematic-debugging.
All Skills by @obra
brainstorming
by @obra
Must be used before any creative work (e.g., feature development, component building) to explore user intent and requirements, ensuring the correct direction.
systematic-debugging
by @obra
Employs a four-stage systematic debugging method, from root cause investigation to solution implementation, to efficiently identify and resolve software defects, ensuring system stability.
writing-plans
by @obra
Develops comprehensive product implementation plans, including detailed documentation paths and execution steps, ensuring timely and efficient project delivery to achieve desired objectives.
using-superpowers
by @obra
Utilizes advanced tools or frameworks to implement efficient and powerful features in backend development, solving complex problems and improving development efficiency, enabling AI coding agents to demonstrate exceptional capabilities.
requesting-code-review
by @obra
Proficiency in initiating code review requests to team members, ensuring AI coding agents submit code that meets quality standards, is logically clear, and free of potential issues, a key aspect of backend development collaboration.
test-driven-development
by @obra
Adheres to Test-Driven Development (TDD) methodology, utilizing the RED-GREEN-REFACTOR cycle to ensure backend code quality, maintainability, and functional correctness.
verification-before-completion
by @obra
Runs verification commands and confirms work is complete, fixed, or passed before committing or creating a PR, ensuring code quality.
executing-plans
by @obra
Ability to translate product plans into concrete execution steps, ensuring AI coding agents can efficiently advance projects according to predefined schemes to achieve product goals, a core practice in product management.
subagent-driven-development
by @obra
Proficiency in driving software development processes by coordinating multiple sub-agents, enabling AI coding agents to decompose complex tasks, process them in parallel, and improve development efficiency and system modularity.
receiving-code-review
by @obra
Ability to understand and effectively incorporate feedback from code reviews, enabling AI coding agents to improve backend code quality, fix issues, and optimize designs based on feedback, fostering team collaboration.
dispatching-parallel-agents
by @obra
Ability to effectively dispatch and manage multiple parallel AI agents to collaboratively complete complex tasks, optimize resource utilization, and significantly enhance the execution efficiency of AI engineering projects.
writing-skills
by @obra
Proficiency in clear, accurate, and concise technical writing, enabling AI coding agents to generate high-quality documentation, reports, and comments, effectively conveying technical information and improving project readability.
using-git-worktrees
by @obra
Skilled in using Git Worktrees, enabling AI coding agents to simultaneously handle multiple branch tasks within the same repository, improving backend development efficiency and context switching convenience.
finishing-a-development-branch
by @obra
Guides on how to integrate code once development work is complete and all tests pass, ensuring a smooth merge of the development branch.
diagnosing-superpowers
by @obra
Use this Skill when an AI coding session went wrong and someone needs to know why. It resolves the session to verified absolute paths, dispatches parallel analysts across seven dimensions — skill timeline, plan adherence, repeated work, stumbles, quality evidence, request conflicts, cost and time — and reports every finding with path:line citations, never from memory. It then drafts a maintainer issue, builds a redacted shareable bundle at the requested level, or scans past sessions for the same failure signature.
remembering-conversations
by @obra
After exploring code or encountering issues, help users think through the best approaches or solutions, providing conversational memory and guidance.
writing-clearly-and-concisely
by @obra
Apply Strunk's timeless writing rules to ANY prose humans will read—documentation, commit messages, error messages, explanations, reports, or UI text. Makes your writing clearer, stronger, and more professional.
finding-duplicate-functions
by @obra
Used for codebase auditing to identify and locate semantically duplicate functions, helping optimize code structure, improve maintainability, and efficiency.
Remembering Conversations
by @obra
This skill allows users to search archived conversations using semantic similarity or exact text matching, quickly retrieving facts, patterns, decisions, and context. It effectively prevents redundant research and the reinvention of solutions, ensuring team decisions are based on complete historical information, thereby significantly boosting development and collaboration efficiency.
Subagent-Driven Development
by @obra
This skill executes implementation plans by dispatching a fresh subagent for each task, incorporating code review between tasks. It ensures high-quality, fast iteration development by maintaining continuous quality gates and preventing context pollution across subagent workflows. This Skill significantly enhances development efficiency and code quality, making it ideal for scenarios requiring continuous progress and robust quality assurance in independent task execution.
Executing Plans
by @obra
This skill enables AI agents to systematically execute detailed plans by processing tasks in batches with integrated review checkpoints. It significantly enhances the accuracy and efficiency of task execution, allowing for human intervention and guidance at critical junctures. This approach minimizes errors and optimizes the overall workflow, ensuring robust and controlled plan implementation.
Dispatching Parallel Agents
by @obra
This skill dispatches multiple AI agents in parallel to concurrently investigate and fix independent problems or tasks. It significantly reduces the time required for troubleshooting and resolving complex issues, especially when dealing with multiple unrelated test failures or independent subsystem breakdowns, thereby greatly enhancing development efficiency and system stability.
Requesting Code Review
by @obra
This skill dispatches a code-reviewer subagent to review code implementations against plans or requirements early in the development process. It helps developers identify and resolve potential issues before they escalate, significantly improving code quality and development efficiency, especially in subagent-driven development and complex feature implementations.
Finishing a Development Branch
by @obra
This skill standardizes and automates the process of finishing a development branch, ensuring code quality and offering clear next steps. It guides developers through test verification, intelligent base branch identification, and structured options like merging, creating a pull request, keeping, or discarding the branch. This helps complete development work efficiently and safely, preventing common mistakes and improving team collaboration.
Using Git Worktrees
by @obra
This skill empowers developers to create isolated Git worktrees efficiently, leveraging smart directory selection and robust safety verification. It allows users to seamlessly work on multiple branches simultaneously without interference, preventing accidental commits and ensuring each workspace maintains a clean, tested baseline environment. This significantly boosts overall development efficiency, reduces context-switching overhead, and enhances code quality and reliability.
Sharing Skills
by @obra
This skill guides users on how to contribute locally developed skills back to an upstream repository using a standard Git workflow (branch, commit, pull request). It ensures the skill contribution process is standardized, traceable, and adheres to community collaboration best practices, thereby improving the quality and maintainability of the skill library.
Writing Plans
by @obra
This skill generates comprehensive, step-by-step implementation plans for engineers, even those with zero codebase context. It meticulously breaks down complex tasks into bite-sized, actionable steps, providing exact file paths, concrete code examples, and precise testing instructions. This significantly enhances development efficiency, standardizes task execution, and improves overall code quality, ensuring smoother project execution and faster onboarding for new team members.
Pulling Updates from Skills Repository
by @obra
This skill helps users synchronize their local skills repository with upstream changes, while preserving personal modifications. It automates Git pull, merge, and conflict resolution processes, ensuring the skills library remains up-to-date and custom content is effectively managed. This enhances the efficiency and stability of skill repository maintenance.
Gardening Skills Wiki
by @obra
This skill automates the maintenance of a skills wiki's health, checking link validity, naming conventions, index coverage, and cross-references. It effectively prevents the tediousness and errors of manual inspection, ensuring the accuracy, consistency, and discoverability of skill content, thereby enhancing the overall quality and user experience of the skill platform.
Meta-Pattern Recognition
by @obra
This skill helps users extract universally applicable core principles by identifying recurring patterns across at least three different domains. It enables developers, architects, or any problem-solver to abstract seemingly independent challenges, thereby discovering and applying proven solutions, avoiding redundant work. This Skill significantly enhances the elegance of system design, the efficiency of problem-solving, and innovation, fostering cross-domain knowledge reuse and the promotion of best practices.
Collision-Zone Thinking
by @obra
This skill helps users break free from conventional thinking by forcing the association of seemingly unrelated concepts, discovering unexpected emergent properties, and generating original solutions. It is particularly effective for tackling complex challenges in system design, code organization, and data management. When traditional methods hit a wall, this Skill effectively sparks breakthrough innovation, enhancing problem-solving efficiency and system design quality.
Tracing Knowledge Lineages
by @obra
This skill helps users trace the evolution of technical ideas and decisions, deeply understanding why current approaches were formed and lessons from past failures. By analyzing historical context, decision records, and failed attempts, this Skill effectively prevents repeating mistakes, rediscovers forgotten yet effective solutions, thereby significantly improving the quality and efficiency of engineering decisions, and fostering more robust software architecture design.
Simplification Cascades
by @obra
This skill identifies core insights to unify multiple similar components or complex rules into elegant abstractions, significantly eliminating system complexity. It helps developers find common patterns, reduce duplicate implementations and special case handling, thereby greatly improving code maintainability, scalability, and development efficiency.
Preserving Productive Tensions
by @obra
This skill helps identify and manage "productive tensions" in software development, recognizing when disagreements or multiple valid approaches offer valuable context rather than being problems to solve. It guides teams to preserve flexibility by making choices configurable or maintaining parallel implementations, rather than forcing premature, suboptimal resolutions. By understanding when to defer decisions or document trade-offs, this skill ensures systems remain adaptable to varying contexts and evolving requirements, preventing unnecessary complexity and maintaining architectural integrity.
amplifier-bundle-superpowers
by @obra
This skill provides a systematic debugging methodology designed to help developers efficiently identify and resolve technical issues. It emphasizes thoroughly investigating to find the root cause before attempting any fixes, thereby avoiding random patches and symptomatic solutions. By following four phases—Root Cause Investigation, Pattern Analysis, Hypothesis and Testing, and Implementation—it ensures problems are completely resolved, saving time, reducing new bugs, and enhancing system stability.
Scale Game
by @obra
This skill tests systems at extreme scales (e.g., 1000x bigger/smaller, instant/year-long) to uncover fundamental truths and hidden issues that are not apparent at normal scales. It helps users identify system limits, potential failure points, and architectural weaknesses, leading to the development of more robust, scalable, and reliable software.
Inversion Exercise
by @obra
This skill guides users to systematically invert core assumptions, uncovering hidden constraints and fostering innovative solutions. It encourages questioning conventional wisdom to break through mental blocks in product development, process optimization, or problem-solving, ultimately enhancing user experience and system resilience.
Systematic Debugging
by @obra
This skill provides a four-phase systematic debugging framework, ensuring thorough root cause investigation before attempting any fixes, thus preventing blind patching and the introduction of new issues. It helps developers efficiently pinpoint and resolve any technical problem, especially under time pressure, ensuring every fix is based on a deep understanding of the problem, thereby improving code quality and system stability.
Root Cause Tracing
by @obra
This skill offers a systematic methodology for tracing software bugs backward through the call stack until their original trigger is identified. It helps developers understand the root cause of issues rather than just fixing symptoms, thereby improving code quality and system stability by effectively resolving deep-seated errors.
Verification Before Completion
by @obra
This skill enforces a strict verification process, requiring users to run specific commands and confirm their output before claiming any work is complete or expressing satisfaction. It helps developers cultivate rigorous work habits by providing clear verification steps and common failure scenarios, preventing issues caused by unverified subjective judgments, and ensuring the authenticity and reliability of deliverables.
Testing Skills With Subagents
by @obra
This skill applies Test-Driven Development (TDD) principles to process documentation, systematically testing the compliance and robustness of other skills by simulating real-world pressure scenarios with subagents. It helps users identify and fix potential agent violations and logical loopholes before skill deployment, ensuring expected behavior, thereby significantly improving skill quality and reducing maintenance costs.
Testing Anti-Patterns
by @obra
This skill helps developers identify and avoid common anti-patterns in software testing, especially regarding the incorrect use of mock objects, such as testing mock behavior, adding test-only methods to production code, and mocking without understanding dependencies. By mastering these principles, users can write more robust, reliable, and maintainable tests that truly verify the actual behavior of the code, thereby improving overall software quality and development efficiency.
Condition-Based Waiting
by @obra
This skill replaces arbitrary fixed delays in asynchronous tests with condition-based polling, ensuring tests only proceed when the required conditions are met. It significantly enhances test stability and reliability, reduces flakiness, and accelerates test execution, making it crucial for addressing pain points in asynchronous operation testing.
Writing Skills
by @obra
This skill applies Test-Driven Development (TDD) principles to process documentation and AI skill creation. By first designing test cases, observing AI agent failures, and then iteratively writing and refining the documentation, it ensures accuracy, clarity, and effectiveness. It helps users create high-quality, reusable reference guides and technical patterns that AI agents can effectively follow, significantly enhancing documentation reliability and AI agent execution efficiency.
using-tmux-for-interactive-commands
by @obra
This skill demonstrates how to use tmux to programmatically control interactive command-line interface (CLI) tools like Vim, Git rebase -i, or Python REPLs. It leverages tmux's detached sessions and `send-keys` to automate real-time input/output, enabling scripting of complex interactive workflows.
browsing
by @obra
This skill provides direct browser control via Chrome DevTools Protocol, enabling management of existing sessions, multi-tab operations, form automation, and content extraction. It's a powerful tool for browser automation and data harvesting.
windows-vm
by @obra
This skill allows you to create, manage, and connect to a headless Windows 11 VM running within Docker, accessible via SSH. It streamlines the process of spinning up, stopping, restarting, or SSHing into a Windows VM, significantly simplifying the setup and maintenance of development and testing environments, thereby boosting efficiency and convenience.
developing-claude-code-plugins
by @obra
Streamlines Claude Code plugin development, modification, testing, release, and maintenance. It synthesizes official docs into actionable steps, patterns, and examples for the complete plugin lifecycle, ensuring fast and correct development.
codex-subagents
by @obra
codex-subagents offloads time-consuming or parallel tasks to background subagents, keeping your main agent's context lean and efficient. It's ideal for scenarios requiring multiple parallel research threads, context isolation to prevent information overload, or executing long-running tasks without blocking the main process. This enables parallel processing and decoupled execution, significantly boosting work efficiency and context management.
working-with-claude-code
by @obra
This skill provides official Claude Code documentation, covering all aspects like CLI, plugins, hooks, MCP servers, skills, and configuration. Get authoritative, comprehensive, and up-to-date information directly, enabling efficient development and troubleshooting.
driving-claude-code-sessions
by @obra
This skill enables launching Claude Code sessions as "workers" to delegate tasks, run parallel processes, and set up supervised workflows. It allows monitoring worker progress, reviewing tool calls, and collecting results, making it ideal for project managers overseeing multiple AI agents to enhance efficiency and control in complex AI development.
prove-claim
by @obra
Utilize a knowledge graph to prove, disprove, or investigate claims about entities and their relationships. It helps explore connections, trace influences, and reason over linked information to find supporting or contradicting evidence.