Rogerio Junior

Clean up AI-generated code slop with a deletion-first approach, ensuring regression safety.

Conduct thorough Rust code reviews focusing on ownership, lifetimes, and error handling.

Conduct in-depth, multi-source research and generate cited reports effortlessly.

Orchestrate evidence-driven tracing to explain ambiguous results and hypotheses.

Safety guardrails for destructive commands to prevent accidental data loss.

Create structured implementation plans by restating requirements and assessing risks.

Best practices for designing REST APIs with a focus on consistency and usability.

Post-deploy canary monitor that detects regressions before they escalate.

Implement and refactor hexagonal architecture for clean, maintainable systems across multiple programming languages.

Comprehensive Playwright E2E testing patterns for building stable and maintainable test suites.

Build production-quality user interfaces that adhere to design standards.

Comprehensive session verification for builds, types, lint, tests, security, and diffs.

Testing patterns for TypeScript/JavaScript using Vitest and Jest, including mocking and coverage.

Save your current session state for future reference and continuity.

Ralph ensures task completion through a self-referential loop with verification.

Execute implementation plans with independent tasks using specialized subagents.

Test in real browsers to debug and verify web applications effectively.

Implement best practices for building scalable NestJS applications with modular architecture.

Best practices for Docker and Docker Compose in local development and container security.

Extract and save reusable patterns from sessions for future reference.

Production patterns for building robust axum services in Rust.

Ensure work is genuinely complete before making claims by verifying results through specific commands.

Coordinate multiple agents on shared tasks using Claude Code's team management tools.

Configure optional skill packs for dog_stack installations.

Master idiomatic .NET/C# patterns for modern application development.

Learn Pythonic idioms, PEP 8 standards, and best practices for efficient Python development.

Simplify code for clarity and maintainability by reducing complexity without altering behavior.

Cleanly exit any active persistent mode and remove all associated state files.

Execute implementation plans with rigorous validation loops to ensure quality.

Automatically generate CI/CD pipelines for various programming stacks using GitHub Actions.

Capture architectural decisions during coding sessions as structured ADRs.

Transform objectives into detailed, executable plans for complex engineering projects.

Efficiently dispatch independent tasks to specialized agents for parallel processing.

Incrementally implement tasks by building, testing, and committing code.

Create detailed implementation plans for multi-step tasks before coding.

Implement production patterns for the Echo framework in Go, including middleware, error handling, and testing.

Quickly answer side questions without interrupting your current task.

Ensure your code adheres to security best practices with this comprehensive security review skill.

Capture architectural decisions and documentation to provide context for future engineers.

Technical writing patterns for effective documentation across various formats.

An instinct-based learning system that evolves behaviors into reusable skills and commands.

Access up-to-date library and framework documentation on demand.

Automate the creation of hierarchical AGENTS.md documentation for codebases.

Schedule recurring dog_stack commands using natural language expressions.

Clean AI-generated code slop with a regression-safe workflow.

Explore idiomatic Go patterns and best practices for building efficient applications.

Import cookies from your real Chromium browser into a headless session for testing.

Delivers changes incrementally to manage large features effectively.

Conducts thorough multi-axis code reviews to ensure code quality before merging.

Create and manage a persistent markdown knowledge base that compounds across sessions.

Guided feature development focusing on codebase understanding and architecture.

Production patterns for building efficient Gin (Go) services.

Automate design audits and fixes with a focus on visual consistency and hierarchy.

Quickly commit changes using natural language descriptions for file targeting.

Analyze and prioritize tickets from a tech lead perspective, focusing on effort, priority, dependencies, and risks.

Frontend development patterns for React and Next.js, focusing on state management and performance optimization.

Idiomatic Kotlin patterns for Android development, including coroutines, Flow, and Jetpack Compose.

Streamline your deployment processes with proven CI/CD patterns and Docker best practices.

Run end-to-end tests with Playwright for critical user flows.

Conduct comprehensive security audits with multiple modes for repository assessment.

Restrict file edits to a specific directory during a session to prevent accidental changes.

Comprehensive Go testing patterns for writing reliable tests using TDD.

Easily configure notification integrations for Telegram, Discord, and Slack using natural language.

Conduct multi-source deep research to synthesize findings into a cited report.

Organize and preserve reusable project knowledge effectively.

Master Python testing with pytest, TDD, and best practices for robust applications.

Resume work seamlessly by loading the most recent session file with full context.

Autopilot executes the full software development lifecycle from idea to working code autonomously.

Streamline complex planning with a three-agent consensus pipeline requiring human approval.

Facilitate spec-driven development with structured specifications and approval gates.

Ultrawork is a parallel execution engine for high-throughput task completion.

Optimize your Next.js 16+ development with Turbopack for faster builds and hot updates.

Conduct thorough TypeScript/JavaScript code reviews focusing on type safety and security.

Efficient web scraping and browser automation using Playwright for dynamic content.

Create isolated Git workspaces for feature development with safety checks.

Streamline your development with Test-Driven Development (TDD) using structured planning and strict cycles.

Implement production-ready FastAPI services with best practices and patterns.

Create detailed implementation plans for features using codebase analysis and pattern extraction.

Systematic Debugging ensures root cause analysis before proposing fixes for any technical issue.

Fetch up-to-date library and framework documentation on demand.

Automate your code shipping process with a fully integrated workflow.

Comprehensive Rust testing patterns for reliable and maintainable code.

Create a comprehensive design system tailored to your product's needs.

Automate GitHub repository management tasks like issue triage, PR handling, and CI/CD operations using the gh CLI.

Automate comprehensive PR reviews with specialized agents for code quality and security.

Orchestrates a 2-stage pipeline for causal investigation and requirements crystallization.

Establish baseline coding conventions for improved code quality and maintainability.

Automate QA testing and bug fixing for web applications with structured reporting.

Configure the HUD display options for optimal statusline visibility.

Build MCP servers using Node/TypeScript SDK with essential tools and resources.

Implement features and bug fixes using Test-Driven Development (TDD) principles.

Orchestrate parallel AI agent sessions using dmux, a tmux pane manager for agents.

Automate the merging, deploying, and verifying of pull requests in production.

Facilitates the transformation of ideas into structured designs before implementation.

Prevent Ethereum hashing bugs in JavaScript and TypeScript with Keccak-256.

Learn idiomatic Rust patterns for safe and performant applications.

Django architecture patterns for scalable and maintainable applications.

Automate visual quality assessment of UI screenshots with Playwright and LLM scoring.

Three-agent pipeline for producing consensus plans before implementation.

Suggests manual context compaction at logical intervals to preserve context through task phases.

Automate the process of merging pull requests and verifying production health.

Generate structured product requirement documents through interactive questioning.

Idiomatic Swift patterns and testing strategies for iOS/macOS projects.

Efficient web scraping and browser automation using Playwright.

A structured four-phase workflow for developing features with clear specifications and human approval gates.

Incrementally fix build and type errors with minimal, safe changes.

Implement idiomatic Laravel and PHP patterns for efficient development.

Create a comprehensive design system tailored to your product needs.

Extract learned skills from conversations to improve problem-solving.

Opinionated workflows for Claude Code, enhancing productivity from brainstorming to deployment.

Conduct thorough Socratic interviews to clarify vague ideas before execution.

Streamline your codebase by managing deprecation and migration effectively.

Set up notification alerts for session events via Telegram, Discord, or Slack.

Automates CI/CD pipeline setup to ensure quality and efficiency in deployments.

Computes a weighted health score for your project based on typecheck, lint, tests, and dead code.

Conduct a thorough security review of your codebase to identify vulnerabilities.

Perform comprehensive code reviews for Go projects focusing on idiomatic practices and performance.

Strategic pre-launch checklist for critical releases ensuring safe deployments.

Capture and recall specific insights from sessions with a persistent JSONL knowledge store.

Conduct thorough Python code reviews focusing on PEP 8, type hints, and security best practices.

Automate code reviews for local changes or GitHub pull requests with comprehensive analysis.

Analyze and prioritize tickets from a tech lead perspective for effective sprint planning.

Design stable interfaces with clear contracts for APIs and modules.

Bun is a fast all-in-one JavaScript runtime, package manager, bundler, and test runner.

Structured four-phase protocol for evidence-first bug investigation.

Create a GitHub PR from your current branch with unpushed commits, analyzing changes and utilizing templates.

Runtime check to ensure required skill packs are enabled before executing commands.

Essential Git workflow patterns for effective version control and collaboration.

Comprehensive patterns and best practices for backend development using Node.js, Express, and Next.js.