Rogerio Junior

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.

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

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

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

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

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

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.

Establish baseline coding conventions for improved code quality and maintainability.

Three-agent pipeline for producing consensus plans before implementation.

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

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

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

Production patterns for building efficient Gin (Go) services.

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

Django architecture patterns for scalable and maintainable applications.

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

Comprehensive Rust testing patterns for reliable and maintainable code.

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

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

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

Capture architectural decisions during coding sessions as structured ADRs.

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.

Create isolated Git workspaces for feature development with safety checks.

Comprehensive Go testing patterns for writing reliable tests using TDD.

Implement idiomatic Laravel and PHP patterns for efficient development.

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

Conduct thorough Socratic interviews to clarify vague ideas before execution.

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

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

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

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

Configure the HUD display options for optimal statusline visibility.

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

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

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

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.

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

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.

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

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

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

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

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

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

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

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

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

Extract and save reusable patterns from sessions for future reference.

Generate structured product requirement documents through interactive questioning.

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

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

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

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

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

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

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

Production patterns for building robust axum services in Rust.

Essential Git workflow patterns for effective version control and collaboration.

Streamline your codebase by managing deprecation and migration effectively.

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

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

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

Safety guardrails for destructive commands to prevent accidental data loss.

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

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

Extract learned skills from conversations to improve problem-solving.

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

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

Guided feature development focusing on codebase understanding and 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.

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.

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

Efficient web scraping and browser automation using Playwright.

Save your current session state for future reference and continuity.

Organize and preserve reusable project knowledge effectively.

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

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

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

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

Learn idiomatic Rust patterns for safe and performant applications.

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

Delivers changes incrementally to manage large features effectively.

Create structured implementation plans by restating requirements and assessing risks.

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.

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