Rogerio Junior

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

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

Learn idiomatic Rust patterns for safe and performant applications.

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

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

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

Delivers changes incrementally to manage large features effectively.

Quickly commit changes using natural language descriptions for file targeting.

Schedule recurring dog_stack commands using natural language expressions.

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

Execute implementation plans with rigorous validation loops to ensure quality.

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

Extract and save reusable patterns from sessions for future reference.

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

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

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

Create a comprehensive design system tailored to your product needs.

Configure optional skill packs for dog_stack installations.

Design stable interfaces with clear contracts for APIs and modules.

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

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

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

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

Facilitates the transformation of ideas into structured designs before implementation.

Conduct comprehensive security audits with multiple modes for repository assessment.

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

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

Efficiently dispatch independent tasks to specialized agents for parallel processing.

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

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

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

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

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

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

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

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

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

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

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

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

Django architecture patterns for scalable and maintainable applications.

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

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

Three-agent pipeline for producing consensus plans before implementation.

Production patterns for building efficient Gin (Go) services.

Establish baseline coding conventions for improved code quality and maintainability.

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

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

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

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

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

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

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

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

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

Automate your code shipping process with a fully integrated workflow.

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

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

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

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

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

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

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

Comprehensive Rust testing patterns for reliable and maintainable code.

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

Capture architectural decisions during coding sessions as structured ADRs.

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

Comprehensive Go testing patterns for writing reliable tests using TDD.

Create isolated Git workspaces for feature development with safety checks.

Implement idiomatic Laravel and PHP patterns for efficient development.

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

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

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

Conduct thorough Socratic interviews to clarify vague ideas before execution.

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

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

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

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

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

Configure the HUD display options for optimal statusline visibility.

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

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

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

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

Technical writing patterns for effective documentation across various formats.

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

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

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

Quickly answer side questions without interrupting your current task.

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

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

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

Streamline your codebase by managing deprecation and migration effectively.

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

Generate structured product requirement documents through interactive questioning.

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

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

Organize and preserve reusable project knowledge effectively.

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

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

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

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

Production patterns for building robust axum services in Rust.

Essential Git workflow patterns for effective version control and collaboration.

Guided feature development focusing on codebase understanding and architecture.

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

Safety guardrails for destructive commands to prevent accidental data loss.

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

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

Extract learned skills from conversations to improve problem-solving.

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

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

Execute implementation plans with independent tasks using specialized subagents.

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

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

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

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

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

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

Efficient web scraping and browser automation using Playwright.

Create structured implementation plans by restating requirements and assessing risks.

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

Save your current session state for future reference and continuity.

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

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

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

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

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

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