Rogerio Junior

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.

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

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

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

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

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

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

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

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

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

Establish baseline coding conventions for improved code quality and maintainability.

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

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

Production patterns for building efficient Gin (Go) services.

Django architecture patterns for scalable and maintainable applications.

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

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

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

Three-agent pipeline for producing consensus plans before implementation.

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

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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

Implement idiomatic Laravel and PHP patterns for efficient development.

Capture architectural decisions during coding sessions as structured ADRs.

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

Create isolated Git workspaces for feature development with safety checks.

Comprehensive Go testing patterns for writing reliable tests using TDD.

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

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

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

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

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

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

Configure the HUD display options for optimal statusline visibility.

Conduct thorough Socratic interviews to clarify vague ideas before execution.

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

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

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

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

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

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

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

Technical writing patterns for effective documentation across various formats.

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

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

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

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

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

Execute implementation plans with rigorous validation loops to ensure quality.

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

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

Save your current session state for future reference and continuity.

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

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

Organize and preserve reusable project knowledge effectively.

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

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

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

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

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.

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

Guided feature development focusing on codebase understanding and architecture.

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

Streamline your codebase by managing deprecation and migration effectively.

Safety guardrails for destructive commands to prevent accidental data loss.

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

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

Quickly commit changes using natural language descriptions for file targeting.

Extract learned skills from conversations to improve problem-solving.

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.

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

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

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.

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

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

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.

Extract and save reusable patterns from sessions for future reference.

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

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

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

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

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

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.

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

Generate structured product requirement documents through interactive questioning.

Delivers changes incrementally to manage large features effectively.

Schedule recurring dog_stack commands using natural language expressions.

Quickly answer side questions without interrupting your current task.

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

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

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.

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

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