skills

../skills/build/SKILL.md

../skills/cleanup/SKILL.md

../skills/commit-all/SKILL.md

../skills/commit/SKILL.md

../skills/continue/SKILL.md

Use this agent when you need rapid development of complete applications, complex system architecture, performance-critical implementations, or when tackling challenging technical problems that require deep expertise across multiple technology stacks. This agent excels at building production-ready applications from scratch, optimizing existing codebases for maximum performance, and implementing sophisticated architectural patterns. Examples: - <example> Context: User needs a complete web application built quickly user: "I need a real-time chat application with user authentication" assistant: "I'll use the architect agent to rapidly build this complete chat application with all the features you need" <commentary> Since the user needs a full application built, use the architect agent to handle the complete implementation. </commentary> </example> - <example> Context: User has performance issues in their codebase user: "This API endpoint is taking 5 seconds to respond" assistant: "Let me bring in the architect agent to analyze and optimize this for maximum performance" <commentary> Performance optimization requires deep expertise, so the architect agent is perfect for this task. </commentary> </example>

Use this agent to merge parallel worktree branches into a single coherent codebase. The consolidator has full context of every subtask's intent and resolves conflicts by understanding code, not by picking sides. Launched automatically by the consolidation skill after parallel worktree agents complete. Can also be invoked directly when you have branches to merge and need intelligent conflict resolution. Examples: <example> Context: Multiple worktree agents have completed their subtasks and their branches need merging. user: "Merge these three feature branches together" assistant: "I'll use the consolidator agent to merge all branches with full context of what each one changed" <commentary> The consolidator agent has the merge protocol, conflict resolution framework, and post-merge verification to handle this cleanly. </commentary> </example> <example> Context: The consolidation skill has completed Phase 3 and needs to merge results. assistant: "Launching the consolidator agent to merge all worktree branches and wire everything together" <commentary> The consolidation skill triggers the consolidator agent for Phase 4 automatically. </commentary> </example>

Use this agent to decompose a task into the smallest reasonable units of work, decide which agents execute each unit, map file overlaps and dependencies, and produce an execution plan optimized for maximum parallelism. The planner is the first step in the consolidation cycle — it reads the codebase, understands the task, and outputs a structured plan that the verifier validates and the conducting agent executes. Examples: <example> Context: A multi-part feature needs to be implemented. assistant: "I'll use the planner agent to decompose this into parallel subtasks before launching any work" <commentary> The planner analyzes the codebase and produces an optimal execution plan with file ownership, agent assignments, and dependency graph. </commentary> </example>

Use this agent when you need an uncompromising code review that catches every possible issue, from critical bugs to minor style inconsistencies. This agent excels at identifying performance bottlenecks, security vulnerabilities, maintainability concerns, and code smells that others might overlook. Perfect for pre-production reviews, critical system components, or when you want to ensure your code meets the highest standards. Examples: <example> Context: The user wants a thorough code review after implementing a new feature. user: "I've just finished implementing the user authentication module" assistant: "I'll use the reviewer agent to perform a comprehensive review of your authentication implementation" <commentary> Since the user has completed a critical security feature, use the reviewer agent to ensure no vulnerabilities or issues exist. </commentary> </example> <example> Context: The user has written performance-critical code. user: "Here's my implementation of the sorting algorithm for our data pipeline" assistant: "Let me invoke the reviewer agent to scrutinize this performance-critical code" <commentary> Performance-critical code requires thorough review, so the reviewer agent should examine every aspect. </commentary> </example>

Use this agent to validate execution plans before work begins (pre-verification) and to confirm that completed work matches expected outcomes (post-verification). The verifier checks plans for correctness, completeness, efficiency, and effectiveness. It catches missing subtasks, unnecessary work, wrong file targets, and broken dependency chains before any agent writes code. Post-execution, it confirms the output matches the plan's acceptance criteria. Examples: <example> Context: The planner has produced an execution plan. assistant: "I'll use the verifier agent to validate this plan before launching any work" <commentary> The verifier catches issues in the plan before expensive parallel agents are spawned. </commentary> </example> <example> Context: All subtasks are complete and consolidated. assistant: "I'll use the verifier agent to confirm the output matches the expected outcome" <commentary> Post-execution verification ensures nothing was missed or implemented incorrectly. </commentary> </example>

House rules and load-bearing patterns for production Android with Jetpack Compose + MVI. Covers the MviViewModel<State,Intent,Effect> contract pattern, DispatcherProvider, collectAsStateWithLifecycle, type-safe Navigation Compose (@Serializable routes) + Navigation3 forward path, Koin DI (not Hilt), strong skipping defaults, edge-to-edge mandate, Material 3 / Expressive + adaptive layouts, Room + DataStore, Turbine + MockK + Robolectric testing scaffold, Baseline Profiles, R8 full mode, composable parameter ordering, module layout, and anti-pattern catalog. **Does not** re-teach elementary Compose (recomposition, remember, LaunchedEffect basics), standard Kotlin/coroutine patterns, or basic Material 3 usage -- assume that baseline. Use when writing or reviewing any Android/Compose code.

Backend API design, database architecture, microservices patterns, and test-driven development. Use for designing APIs, database schemas, or backend system architecture.

Build the project (auto-detects build system)

Find and remove dead code, unused imports, and technical debt

Create git commits in logical groups for all current changes