dotfiles

Use opensrc to access the source code of any library — open source or internal — whenever you need to understand how it works. Trigger this whenever you are researching, debugging, exploring, or implementing anything that involves a dependency you need to inspect. Source code is the source of truth. Always prefer it over guessing, reading docs, or reverse-engineering artifacts (e.g. JARs, minified bundles). Use official docs only for pure signature lookups (method name, argument types) where the docs are unambiguous. In all other cases — behavior questions, edge cases, internal libs, version-specific details — fetch the source.

Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

Autonomous execution agent that picks up unblocked tickets and writes production-ready code to resolve them. Use this skill when the user says "start building", "execute the next ticket", "pick up a ticket", "run Ralph", "start the execution loop", "work on the feature", "build this", or after the kanban-generator has produced tickets. Also trigger when the user returns to a project and says "continue where we left off", "what's next", or "keep going". Supports two modes: **branch mode** (default) checks out a feature branch directly in the working directory without creating a worktree; **worktree mode** creates an isolated git worktree per PRD at plan/worktrees/<prd-name>. Say "use worktree mode" or "run with worktrees" to activate worktree mode. Say "run in parallel" to work on multiple PRDs simultaneously (worktree mode only). **Always stops after each ticket for review** — never runs tickets back-to-back autonomously. Committing and merging are always left to the user — Ralph never commits or merges. Chan

Scoping assistant that takes a raw idea — whether it's a full app, a feature, a bug fix, or a refactor — and expands it into a clear, actionable scope through structured questioning. Use this skill whenever the user says things like "I have an idea", "I want to build...", "what would it take to...", "help me scope this", "is this a big change?", "I'm thinking about adding...", or any time someone presents an unrefined concept that needs clarification before work begins. Also trigger when the user seems unsure about the size or complexity of something they want to build. This is the FIRST step in the development pipeline — it comes before research, prototyping, or PRD writing. Even seemingly small ideas benefit from 5 minutes of scoping.

Technical Lead that breaks a finalized PRD into specific, actionable execution tickets with explicit blocking relationships. Use this skill when the user says "break this into tickets", "create issues from the PRD", "generate tasks", "turn this into a kanban board", "what are the tickets", "break this down", or after a PRD is finalized and approved. Also trigger when the user asks "what should we build first?" or "what's the execution order?" for an existing PRD. The output is a structured markdown file with tickets that are small enough for a single agent session to execute, with clear dependency chains. These can be manually copied to Linear or any project management tool.

Product Manager that aggressively grills the user on every decision branch before writing a formal Product Requirements Document (PRD). Use this skill when the user says "write a PRD", "let's spec this out", "I need a requirements doc", "formalize this", "write the spec", "document the requirements", or when transitioning from prototyping/research to formal planning. Also trigger when someone says "what are we actually building?" or seems ready to lock in requirements after exploration. This skill deliberately challenges assumptions and uncovers edge cases BEFORE writing — it's designed to be uncomfortable but thorough. The output is a formal PRD that downstream skills (kanban-generator, execution-loop) consume directly.

QA Engineer that generates step-by-step human testing plans and converts test failures into actionable bug tickets. Use this skill when the user says "create a QA plan", "how do I test this", "write test cases", "QA this feature", "is this ready for review", "generate a test plan", "I need to test this", or after the execution-loop completes all tickets for a feature. Also trigger when the user reports bugs or test failures and needs them formatted as tickets for the execution loop. The output is a qa-plan.md checklist that a human can walk through to verify the feature meets PRD requirements, plus the ability to convert failures into new execution tickets.

Technical researcher that explores APIs, libraries, architectural patterns, or any unfamiliar technology and produces a comprehensive research.md document. The goal is to front-load all exploration so that downstream coding agents never need to search docs or guess. Use this skill when the user says "research this API", "I need to integrate with...", "how does X work", "look into this library", "I've never used X before", "gather docs on...", or when the idea-expander skill recommends a research phase. Also trigger when the user is about to build something involving an API, library, or pattern they haven't used before — even if they don't explicitly say "research". The output is a cached knowledge document that future skills and agent sessions can consume without re-searching.

Rapid prototyper that generates 2-3 isolated implementations or UI layouts on throwaway routes so the user can impose their taste before committing to a formal spec. Use this skill when the user says "prototype this", "let me see a few options", "I want to try different approaches", "mock this up", "what would this look like", "let's experiment with...", "I need to see it before I decide", or when the idea-expander recommends exploring before committing. Also trigger when the user is making a UX decision, choosing between architectural approaches, or needs visual or behavioral feedback before writing a PRD. Speed and experimentation matter more than clean code here — these prototypes are explicitly disposable.