Affaan Mustafa

Develop and refactor Quarkus 3.x LTS services by writing tests first. Covers API responses, event handling, and asynchronous operations, with unit and integration tests plus coverage checks to show how much code is tested.

• Adding REST endpoints with tests first
• Reproducing bugs before fixing them
• Testing Apache Camel routes and event handling

Break an RFC, a written design proposal, into work units with dependencies and acceptance tests for multiple agents. Organize research, implementation, testing, review, queued merges, and final system verification for features too large for one pass.

• Splitting a large design proposal into verifiable work units
• Assigning dependent tasks to multiple agents
• Managing review and queued merges of agent-built branches

Review and refactor React and Next.js code to address slow loading and interactions. Prioritized guidance covers sequential data requests, downloaded JavaScript size, server processing, repeated rendering, and browser work, with examples for choosing relevant improvements.

• Investigating slow page loads
• Reviewing downloaded JavaScript size
• Reducing repeated rendering and interaction delays

Organize a task into parallel work streams with clear dependencies, separate places for changes, and explicit checks. Batch independent reads and tests, coordinate concurrent work, and report completed or blocked tasks with verification results.

• Batching independent file reads and searches
• Splitting implementation across multiple agents
• Separating changes with Git worktrees

Build and review React 18/19 components with guidance on state management, data fetching, forms, loading states, and error handling. It also covers keyboard access and how to divide components between server and browser execution.

• Reviewing React components
• Choosing where shared state belongs
• Designing forms and data fetching

Build Redis caching, request limits, locks that coordinate multiple workers, and messaging. Use concrete implementation patterns to choose data structures, set key expiration, manage connections, and review common production pitfalls.

• Add response caching to an API
• Limit API requests per user
• Prevent workers from running the same job simultaneously

Build and review Python tests with pytest. Use reusable setup, simulated external services, and multiple input cases to check behavior, then measure coverage—the proportion of code exercised by tests—and follow a test-first development cycle.

• Writing tests before implementing a Python feature
• Sharing test setup through reusable fixtures
• Testing external API behavior with mocks

Adds checks before an agent runs destructive commands and restricts file edits to a chosen directory. Offers separate or combined protection modes for production work, autonomous sessions, migrations, deployments, and data changes.

• Checking dangerous commands before production work
• Restricting edits to a specific directory
• Combining protections for autonomous agent sessions

Present local Markdown plans and HTML artifacts in a browser for review. People can annotate specific elements, chat, and approve or request changes, while the agent receives structured feedback and file edits appear automatically.

• Reviewing and approving an implementation plan
• Pointing to specific changes in a design
• Annotating a report or comparison

Research existing solutions before implementing a feature. Search project code, package registries, agent tools, and GitHub, then compare functionality, maintenance, licensing, and dependencies to decide whether to adopt, extend, combine, or build.

• Researching existing solutions before adding a feature
• Comparing packages before adding a dependency
• Finding tools for an external integration

Design and review Prisma database code for TypeScript backends. Use examples for schemas, queries, transactions, pagination, migrations, and connection management to identify common pitfalls in bulk operations and serverless deployments.

• Designing database models and relationships with Prisma
• Reviewing queries and pagination
• Investigating transaction and bulk update problems

Build or review Ruby on Rails applications by separating business operations, forms, and database queries into focused objects. Covers efficient data loading, background jobs, reusable view components, Hotwire interactions, and Rails 8 database-backed services.

• Moving business logic out of large controllers
• Designing forms that update multiple models
• Reviewing repeated database queries and data loading

Reviews papers, research proposals, and literature reviews using a consistent scoring guide. Examines methods, evidence, citations, and writing, then separates serious problems from revision suggestions and identifies concrete next edits.

• Reviewing a paper before submission
• Checking whether citations support claims
• Evaluating research methods and limitations

Support manufacturing quality investigations from containment through root cause analysis and corrective action. Organize decisions about nonconforming materials, assess whether actions prevent recurrence, interpret process control charts, and address supplier quality problems.

• Investigating nonconforming materials found during inspection
• Selecting a root cause analysis method
• Preparing corrective action plans and checking effectiveness

Write and run Perl tests with Test2::V0 or Test::More, replace external dependencies with controlled test substitutes, and measure coverage—the code exercised by tests. Guidance covers test-first development, failure diagnosis, and migration between testing modules.

• Writing Perl tests before implementation
• Migrating tests from Test::More to Test2::V0
• Testing API and database interactions in isolation

Turn a multi-step plan into ready-to-paste ECC slash commands, text commands entered with a slash. Each generated command includes its step identifier, task scope, and acceptance criteria. Steps that cannot carry their scope are marked as blocked for manual handling.

• Turning an implementation plan into commands for each step
• Choosing commands for feature additions, fixes, and refactoring
• Generating commands for a selected step or range

Guide PostgreSQL database design and troubleshooting with examples for faster queries, indexes that speed up searches, suitable data types, and row-level access rules. Also covers connection settings and SQL for investigating performance problems.

• Investigating slow PostgreSQL queries
• Choosing indexes and column data types
• Designing row-level access rules

Write, review, and refactor Rust code using established conventions for ownership, error handling, type design, and concurrency. It guides safer implementations, avoids unnecessary copying, and organizes modules with a limited public interface.

• Review ownership and borrowing in Rust code
• Replace panic-prone error handling
• Design types and modules for a Rust application

Review installed skills to identify shared working principles and compare them with existing rules. Produce evidence-backed proposals to add, revise, or create rule files, then apply only the changes the user approves.

• Reviewing rules after installing new skills
• Consolidating principles repeated across skills
• Finding gaps or outdated wording in existing rules

Plan manufacturing jobs around available machines, operators, materials, and delivery dates. Use bottleneck analysis, changeover planning, and workload balancing to compare production sequences and revise schedules when breakdowns, shortages, or absences disrupt the plan.

• Sequence jobs competing for limited equipment
• Revise production schedules after equipment breakdowns
• Compare batch sizes and changeover costs

Design recommendation and ranking workflows that select the best items for a user or situation. Organize candidate retrieval, enrichment, filtering, scoring, selection, and background recording into six stages, then generate a runnable code scaffold.

• Designing personalized content feeds
• Reranking search or RAG results
• Building task prioritization workflows

Plan literature searches, screen academic and technical sources, and combine findings into a cited review. Records search methods and exclusions, compares conflicting evidence, identifies research gaps, and checks references so readers can trace the review's claims.

• Mapping existing research on a topic
• Preparing a review with documented search methods
• Finding contradictions and gaps across studies

Verify Quarkus services before pull requests or deployment through builds, code analysis, tests, coverage reports, and security scans. The workflow also checks native executables, containers, performance, health endpoints, configuration, and documentation.

• Checking a Quarkus service before a pull request
• Verifying refactoring or dependency upgrades
• Checking native executable compatibility

Turn product requests and planning documents into a concrete development plan. Document business rules, data ownership, service interfaces, and unresolved decisions so teams can see what must be settled before implementation begins.

• Turning a product requirements document into development requirements
• Aligning requirements for a feature spanning multiple services
• Documenting assumptions that repeatedly surface in reviews