Affaan Mustafa

Record web application demos with Playwright, a browser automation tool. The workflow explores the interface, rehearses each step, and produces WebM videos with visible cursor movement, subtitles, and readable pacing.

• Creating a video walkthrough of a new feature
• Recording tutorials for new users
• Adding operation videos to documentation

Turn visual preferences and local references into reusable style packs, validated settings for look and rhythm. Plan cuts for local footage, export editable timelines, and prepare image, video, or 3D asset plans without calling generation providers.

• Interview for visual direction and create a reusable style pack
• Validate style packs and audit their sources
• Plan local footage cuts using measured reference rhythm

Find existing skills before building a new one. Search local installations, marketplaces, GitHub, and the web, then review candidates for relevance and risky behavior to help choose between reuse, extension, and fresh creation.

• Finding a skill for a specific workflow
• Checking for duplicates before building a skill
• Choosing an existing skill to extend

Write, review, and refactor Python code using PEP 8 style conventions, type hints that describe expected data types, and clear error handling. Includes package organization and memory-conscious patterns to support readable, maintainable applications.

• Reviewing Python code for readability and style
• Adding type hints and improving error handling
• Organizing Python packages and modules

Review Perl code that handles user input, files, external commands, databases, and web output. Use concrete examples and a security checklist to identify unsafe patterns and apply input validation, parameterized queries, and appropriate output encoding.

• Reviewing user input validation in Perl
• Checking file access and external command execution
• Preventing SQL injection in DBI queries

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

Assess whether an application is ready for production using local files and authorized evidence. Reviews authentication, data, payments, and operations, then reports release blockers, prioritized fixes, and a readiness score without uploading repository contents to an external audit service.

• Checking application readiness before launch
• Reviewing release risks after a merge
• Finding production risks beyond passing CI checks

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

Write, review, and modernize Perl 5.36+ applications using clear function parameters, focused error handling, and organized modules. Includes examples for classes, regular expressions, file operations, formatting, code checks, and dependency management.

• Write new Perl code and modules
• Review code against modern Perl conventions
• Update legacy code for Perl 5.36+

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

Set up Plankton hooks in Claude Code to format and lint files after each edit. Route remaining violations to Claude for fixes, verify the results, and protect linter settings from changes that weaken checks.

• Formatting and linting files after every edit
• Setting up automatic fixes for remaining violations
• Protecting linter configuration from rule weakening

Prepare to audit a codebase spanning several technologies by installing the external repo-scan skill from a fixed, reviewable commit. This entry provides the installation procedure; the code audit requires invoking the installed skill separately.

• Installing the audit skill before reviewing a legacy codebase
• Preparing an audit before a major refactor
• Preparing to inspect third-party code bundled in source

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

Triage GitHub issues and pull requests, classify their next steps, and connect active work to Linear. Keeps public updates in GitHub and internal ownership and priorities in Linear, with a clear recommendation for the next action.

• Sorting a backlog of open issues and pull requests
• Deciding whether GitHub work needs a Linear task
• Linking active work to internal owners and priorities

Use the gget command line or Python package to look up genes, retrieve sequences, compare similar sequences, and explore biological database results. Save outputs and query details to support reproducible first-pass bioinformatics research.

• Finding gene identifiers and transcript information
• Retrieving nucleotide or amino-acid sequences
• Running quick BLAST or BLAT sequence searches

Implement and review security measures in Quarkus applications. Covers sign-in, access permissions, input validation, password hashing, secret storage, request limits, audit logs, and checks for known vulnerabilities in dependencies, with implementation and configuration examples.

• Adding JWT or OIDC authentication to a Quarkus API
• Checking role permissions and resource ownership
• Reviewing input validation and database queries

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

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

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

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

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

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

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 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