Rogerio Junior

Answer a quick side question without interrupting or losing context from the current task. Resume work automatically after answering.

Incrementally fix build and type errors with minimal, safe changes

Implement the next task incrementally — build, test, verify, commit

Cleanly exit any active persistent mode (ralph, ultrawork, autopilot, ralplan, team, swarm) and clean up all state files

Generate CI/CD pipeline detecting stack — GitHub Actions for TS/Bun, Python, Go or Rust projects

Simplify code for clarity and maintainability — reduce complexity without changing behavior

Three-agent consensus planning pipeline (Planner → Architect → Critic) with human approval gate before implementation.

Design system consultation — understand product, research landscape, propose complete design system and generate DESIGN.md

Alias for the documentation-lookup skill — uses Context7 MCP for up-to-date library and framework docs.

Alias for the e2e-testing skill — E2E tests with Playwright, Page Object Model, CI/CD integration.

Guided feature development with codebase understanding and architecture focus

Go specialist code review — idiomatic Go, concurrency, error handling, performance

Land and deploy — merge PR, wait for CI to pass, verify production health via canary checks

Extract reusable patterns from the session, self-evaluate quality before saving, and determine the right save location (Global vs Project).

Configure notification integrations — Telegram, Discord, or Slack alerts for session events

Configure which optional skill packs are enabled — run after installing dog_stack

Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.

Quick commit with natural language file targeting — describe what to commit in plain English

Execute an implementation plan with rigorous validation loops

Create comprehensive feature implementation plan with codebase analysis and pattern extraction

Interactive PRD generator - problem-first, hypothesis-driven product spec with back-and-forth questioning

Create a GitHub PR from current branch with unpushed commits — discovers templates, analyzes changes, pushes

Python specialist code review — PEP 8, type hints, Pythonic idioms, security

Multi-source deep research — searches the web, synthesizes findings, delivers cited report

Load the most recent session file from ~/.claude/session-data/ and resume work with full context from where the last session ended.

Code review — local uncommitted changes or GitHub PR (pass PR number/URL for PR mode)

Comprehensive PR review using specialized agents — code quality, security, and language-specific patterns.

Rust specialist code review — ownership, lifetimes, error handling, unsafe usage

Save current session state to a dated file in ~/.claude/session-data/ so work can be resumed in a future session with full context.

Web scraping and browser automation with Playwright — always browser-based, never fetch/axios

Security review — authentication, user input, secrets, API endpoints, OWASP Top 10

Clean AI-generated code slop — deletion-first, regression-safe cleanup without drifting scope

Start spec-driven development — write a structured specification, plan, and task list with human approval gates before writing code.

TDD with planning via the architect agent + strict RED-GREEN-REFACTOR cycle + 80%+ coverage

Analyze and prioritize tickets — tech lead perspective: effort, priority matrix, dependencies, risks

TypeScript/JavaScript specialist code review — type safety, async correctness, security, idiomatic patterns

Alias for the verification-before-completion skill — comprehensive session verification: build, types, lint, tests, security, diff.

REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

axum production patterns — tower middleware, extractors, typed state, error handling with IntoResponse, SQLx integration, tracing, testing with axum-test. Use when building or reviewing axum services in Rust.

Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.

Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.

Echo (Go) production patterns — typed context, route groups, middleware chain, binding/validation, custom HTTPErrorHandler, graceful shutdown, and testing. Use when building or reviewing Echo services. Compare with gin-patterns for framework choice.

FastAPI production patterns — Pydantic models, dependency injection, async DB, middleware, auth (OAuth2/JWT), background tasks, error handling, OpenAPI customization, and pytest-asyncio testing. Use when building or reviewing FastAPI services.

Gin (Go) production patterns — routing groups, middleware, binding/validation, structured error responses, graceful shutdown, context propagation, and testing with httptest. Use when building or reviewing Gin services.

Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration across TypeScript, Java, Kotlin, and Go services.

Guides stable interface design — module boundaries, type contracts between modules, GraphQL schemas, component props, and frontend/backend boundaries. For REST/HTTP endpoint patterns (status codes, pagination, versioning), use `api-design` instead.

Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API.

Prevent Ethereum hashing bugs in JavaScript and TypeScript. Node's sha3-256 is NIST SHA3, not Ethereum Keccak-256, and silently breaks selectors, signatures, storage slots, and address derivation.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Safety guardrails for destructive commands — warns before rm -rf, DROP TABLE, force-push, git reset --hard, kubectl delete and similar. User can override each warning. Use when touching prod or shared environments.

Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

Baseline cross-project coding conventions for naming, readability, immutability, and code-quality review. Use detailed frontend or backend skills for framework-specific patterns.

Three-agent pipeline (Planner → Architect → Critic) that produces a consensus plan before implementation. Requires explicit human approval at the gate before proceeding to /dog:prp-implement. Use when a feature or refactor is complex enough that a single agent's plan could miss blind spots.

Chief Security Officer audit — four modes: secrets archaeology (git history scan), supply chain audit (npm/pip/go/cargo auditors), CI/CD security review (GitHub Actions), and STRIDE threat modeling. Use when you need a comprehensive security posture report for a repository.

Deep codebase initialization with hierarchical AGENTS.md documentation

Multi-source deep research using firecrawl and exa MCPs. Searches the web, synthesizes findings, and delivers cited reports with source attribution. Use when the user wants thorough research on any topic with evidence and citations.

Use up-to-date library and framework docs via Context7 MCP instead of training data. Activates for setup questions, API references, code examples, or when the user names a framework (e.g. React, Next.js, Prisma).

Restrict file edits to a specific directory for the session. Blocks Edit and Write outside the allowed path. Use when debugging to prevent accidentally fixing unrelated code, or to scope changes to one module.

Computes a weighted 0-10 health score across typecheck, lint, tests, and dead code. Persists baseline in ~/.dog/health/{repo-slug}.json and reports delta vs previous run. Use when you want a quick signal on project quality or to track quality trend over time.

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Four-phase bug investigation protocol (Investigate → Analyze → Hypothesize → Implement) that enforces evidence-first debugging. Code edits are prohibited until a confirmation test fails. Use when encountering any bug, test failure, or unexpected behavior before proposing fixes.

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Four-phase spec-driven workflow (Specify → Plan → Tasks → Implement) with human approval gates after Plan and Tasks phases. Use when starting any non-trivial feature to ensure alignment on requirements before writing code.

Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Use when implementing any feature or bugfix, before writing implementation code

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

Use when you have a spec or requirements for a multi-step task, before touching code

Post-deploy canary monitor. Establishes a baseline (p50/p95 latency + error rate) in ~/.dog/canary/{slug}/baseline.json, polls metrics after deploy, and alerts if any metric exceeds 2σ above baseline. Use after deploying to production to detect regressions before they escalate.

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

Multi-agent orchestration using dmux (tmux pane manager for AI agents). Patterns for parallel agent workflows across Claude Code, Codex, OpenCode, and other harnesses. Use when running multiple agent sessions in parallel or coordinating multi-agent development workflows.

Docker and Docker Compose patterns for local development, container security, networking, volume strategies, and multi-service orchestration.

GitHub repository operations, automation, and management. Issue triage, PR management, CI/CD operations, release management, and security monitoring using the gh CLI. Use when the user wants to manage GitHub issues, PRs, CI status, releases, contributors, stale items, or any GitHub operational task beyond simple git commands.

Git workflow patterns including branching strategies, commit conventions, merge vs rebase, conflict resolution, and collaborative development best practices for teams of all sizes.

Land and deploy workflow. Merges the PR, waits for CI and deploy, verifies production health via canary checks. Takes over after /ship creates the PR. Use when: "merge", "land", "deploy", "merge and verify", "land it", "ship it to production".

Strategic pre-launch checklist for critical releases — feature flags, monitoring setup, staged rollout, rollback plan. Distinct from `ship` (branch → PR) and `land-and-deploy` (merge → canary). Use when a release needs explicit launch-quality gates beyond routine deploy, e.g. high-visibility features, breaking changes, data migrations.

Ship workflow: detect + merge base branch, run tests, review diff, bump VERSION, update CHANGELOG, commit, push, create PR. Use when asked to "ship", "deploy", "push to main", "create a PR", "merge and push", or "get it deployed". Proactively invoke this skill (do NOT push/PR directly) when the user says code is ready, asks about deploying, wants to push code up, or asks to create a PR.

Design consultation: understands your product, researches the landscape, proposes a complete design system (aesthetic, typography, color, layout, spacing, motion), and generates font+color preview pages. Creates DESIGN.md as your project's design source of truth. For existing sites, use /plan-design-review to infer the system instead. Use when asked to "design system", "brand guidelines", or "create DESIGN.md". Proactively suggest when starting a new project's UI with no existing design system or DESIGN.md.

Designer's eye QA: finds visual inconsistency, spacing issues, hierarchy problems, AI slop patterns, and slow interactions — then fixes them. Iteratively fixes issues in source code, committing each fix atomically and re-verifying with before/after screenshots. For plan-mode design review (before implementation), use /plan-design-review. Use when asked to "audit the design", "visual QA", "check if it looks good", or "design polish". Proactively suggest when the user mentions visual inconsistencies or wants to polish the look of a live site.

Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices.

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Bun as runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes, and Vercel support.

Idiomatic .NET/C# patterns — LINQ, async/await, records, xUnit testing, dotnet format, and build commands. Covers minimal APIs, dependency injection, Entity Framework, and common pitfalls. Use when working on .NET projects.

Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable Go applications.

Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage. Follows TDD methodology with idiomatic Go practices.

Idiomatic Kotlin patterns for Android development — coroutines, Flow, Jetpack Compose, JUnit/Espresso testing, ktlint, and Gradle build commands. Use when working on Android or Kotlin JVM projects.

Idiomatic Laravel/PHP patterns — Eloquent, service layer, PHPUnit/Pest testing, Laravel Pint formatting, and build commands. Covers request validation, jobs/queues, events, and common anti-patterns. Use when working on Laravel PHP projects.

NestJS architecture patterns for modules, controllers, providers, DTO validation, guards, interceptors, config, and production-grade TypeScript backends.

Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.

Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.

Idiomatic Rust patterns, ownership, error handling, traits, concurrency, and best practices for building safe, performant applications.

Rust testing patterns including unit tests, integration tests, async testing, property-based testing, mocking, and coverage. Follows TDD methodology.

Idiomatic Swift patterns, XCTest testing, SwiftLint, and build commands for iOS/macOS projects. Covers value types, optionals, concurrency (async/await, actors), error handling, and Swift Package Manager. Use when working on Swift projects.

TypeScript/JavaScript testing patterns — Vitest (preferred) and Jest, with test organization, mocking, snapshot testing, coverage, fixtures, and integration with Playwright. Use when writing or reviewing TypeScript/JavaScript unit and integration tests.

Full autonomous execution from idea to working code

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

Self-referential loop until task completion with configurable verification reviewer

Use when executing implementation plans with independent tasks in the current session

N coordinated agents on shared task list using Claude Code native teams

Evidence-driven tracing lane that orchestrates competing tracer hypotheses in Claude built-in team mode

Parallel execution engine for high-throughput task completion

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Clean AI-generated code slop with a regression-safe, deletion-first workflow and optional reviewer-only mode

Capture architectural decisions made during Claude Code sessions as structured ADRs. Auto-detects decision moments, records context, alternatives considered, and rationale. Maintains an ADR log so future developers understand why the codebase is shaped the way it is.

Turn a one-line objective into a step-by-step construction plan for multi-session, multi-agent engineering projects. Each step has a self-contained context brief so a fresh agent can execute it cold. Includes adversarial review gate, dependency graph, parallel step detection, anti-pattern catalog, and plan mutation protocol. TRIGGER when: user requests a plan, blueprint, or roadmap for a complex multi-PR task, or describes work that needs multiple sessions. DO NOT TRIGGER when: task is completable in a single PR or fewer than 3 tool calls, or user says "just do it".

Configure notification integrations (Telegram, Discord, Slack) via natural language

Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents. v2.1 adds project-scoped instincts to prevent cross-project contamination.

Configure HUD display options (layout, presets, display elements)

Extract a learned skill from the current conversation

Persistent JSONL knowledge store for cross-session learnings. Saves entries via /dog:learn, searches and lists via /dog:learnings. Use when you want to capture a specific insight, decision, or technique from the current session for future recall.

Review reusable project knowledge and decide what belongs in project memory, notepad, or durable docs

Schedule recurring dog_stack commands using natural language (every 2h, daily 09:00, weekly Mon 10:00). Persists entries in ~/.dog/cron/{id}.json and documents integration with at/cron/systemd-timer. Use when you want to run a command on a recurring schedule.

Analyze and prioritize tickets from a tech lead perspective — effort estimation, priority matrix, dependency mapping, and actionable recommendations. Use when planning sprints, triaging backlogs, or preparing for stakeholder discussions.

Technical writing patterns for PRDs, ADRs, tech specs, PR descriptions, and commit messages. Use when producing any technical documentation, written deliverable, or structured communication.

2-stage pipeline: trace (causal investigation) -> deep-interview (requirements crystallization) with 3-point injection

Socratic deep interview with mathematical ambiguity gating before autonomous execution

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

LLM Wiki — persistent markdown knowledge base that compounds across sessions (Karpathy model)

Tests in real browsers. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data via Chrome DevTools MCP.

Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.

Playwright-first web scraping and browser automation patterns. Use whenever scraping, crawling, browser automation, or data extraction from web pages is needed. Never use fetch/axios for browser-rendered content.

Systematically QA test a web application and fix bugs found. Runs QA testing, then iteratively fixes bugs in source code, committing each fix atomically and re-verifying. Use when asked to "qa", "QA", "test this site", "find bugs", "test and fix", or "fix what's broken". Proactively suggest when the user says a feature is ready for testing or asks "does this work?". Three tiers: Quick (critical/high only), Standard (+ medium), Exhaustive (+ cosmetic). Produces before/after health scores, fix evidence, and a ship-readiness summary. For report-only mode, use /qa-only. Voice triggers (speech-to-text aliases): "quality check", "test the app", "run QA".

Import cookies from your real Chromium browser into the headless browse session. Opens an interactive picker UI where you select which cookie domains to import. Use before QA testing authenticated pages. Use when asked to "import cookies", "login to the site", or "authenticate the browser".

Visual QA of UI screenshots using Playwright capture + LLM vision scoring. Scores layout, typography, contrast, spacing, and brand consistency (0-10 each). Persists verdict JSON in .dog/visual/. Use when you need a systematic visual quality check of a running UI.