Affaan Mustafa

Audit scheduled jobs, hooks, MCP servers, and external integrations using configuration files, logs, and recent runs. Distinguish configured tools from verified working ones, identify failures or overlap, and recommend what to keep, merge, remove, or fix next.

• Checking which automations are actually working
• Identifying broken jobs and authentication failures
• Finding duplicate hooks, scripts, and integrations

Measure web page speed, API response times, and build or test duration. Save baseline measurements as JSON tracked in Git, then compare results before and after changes to identify performance regressions and assess launch targets.

• Comparing performance before and after a code change
• Investigating reports that a page feels slow
• Checking performance targets before launch

Design and audit interfaces for Web, iOS, and Android using WCAG 2.2 accessibility guidance. Check screen-reader labels, keyboard navigation, contrast, and control sizes to identify barriers and guide implementation for people using assistive technology.

• Adding descriptive labels to icon-only buttons
• Reviewing keyboard navigation and modal focus
• Checking contrast and control sizes

Design caching for repeated PDF parsing, text extraction, or image analysis using SHA-256 hashes, identifiers calculated from file contents. Reuse results after files move or change names, and process them again when their contents change.

• Caching repeated PDF text extraction
• Reusing results after files move or change names
• Adding caching around existing processing functions

Design and refine an AI agent’s available actions, tool inputs, and result formats. Define recovery steps for errors, manage the information kept in context, and evaluate changes through completion rates, retries, and cost per successful task.

• Define an AI agent’s tool set and input formats
• Make tool results and next steps easier to interpret
• Specify safe retries and stopping conditions

Turn scored competitor profiles into a report for strategic decisions. Organize market maps, comparison tables, unoccupied positions, threats, and prioritized recommendations so leaders can decide whom to compete with and how to differentiate.

• Preparing a competitive report for leadership or a board
• Combining completed competitor profiles
• Assessing room for differentiation and competitive threats

Integrate x402, an HTTP payment protocol, so agents can pay for APIs or services. Configure task and session budgets, approved recipients, and wallets with privately managed keys, using integration paths for Base, X Layer, or Solana.

• Enable an agent to pay for a paid API
• Set task and session spending limits
• Restrict payment recipients, networks, and assets

Helps design ClickHouse tables, write analytical queries, and improve slow queries. Covers loading data in batches, preparing reusable summaries, and monitoring performance for large datasets, real-time dashboards, and time-series analysis.

• Designing tables for large-scale analytics
• Improving slow aggregation queries
• Loading large datasets in batches

Add an external API integration that follows the project's existing structure. Use current connectors as models for configuration, authentication, error handling, registration, and tests, so the new integration fits the surrounding code.

• Adding a Jira connector to an existing project
• Building a Slack provider using current project conventions
• Completing integration registration and tests

Configure ECC in Claude Code, Codex, or Kimi with a guided setup workflow. It checks the current installation, previews supported changes, requests confirmation, applies them, and verifies the result.

• Installing or updating ECC
• Changing installation scope in Claude Code
• Adjusting ECC hook automation in Claude Code

Review how easy code is to maintain using CodeScene MCP. Compare structural health scores before and after edits, identify design issues, and check commits and pull requests for changes that reduce maintainability.

• Reviewing an unfamiliar file before editing
• Checking whether AI edits reduce maintainability
• Refactoring while comparing health scores

Supports freight carrier selection, rate negotiations, bid requests, performance reviews, and shipment allocation. Uses US transportation practices to compare costs, service quality, and available capacity when planning carrier contracts and renewals.

• Screening new freight carriers
• Preparing freight bid requests
• Negotiating rates and fuel surcharges

Define team processes for codebases largely implemented by AI agents. Covers planning, ownership rules, architecture, review criteria, and testing requirements, helping teams assess generated code through measurable acceptance criteria, system behavior, and regression checks.

• Defining team processes for AI-generated code
• Setting code review criteria and approval gates
• Choosing architecture that agents can work with

Test deployed web pages through browser automation. Check forms, login flows, loading and responsiveness metrics, visual changes at three screen widths, and accessibility issues, then receive a report with fixes and a release verdict.

• Testing a feature deployed to staging or preview
• Checking forms and login flows before release
• Comparing layouts at three screen widths

Structure Android and Kotlin Multiplatform projects with clear boundaries between business logic, screens, and data access. Provides examples for module dependencies, business operations, repositories that coordinate data sources, database integration, and error handling.

• Planning Android or KMP module boundaries
• Separating business logic from screen code
• Coordinating local and remote data sources

Organize engineering work carried out by AI agents with clear completion criteria, small verifiable tasks, and evaluations before and after implementation. Match model choice to task complexity and track tokens, retries, time, and outcomes to manage cost.

• Planning development work for AI agents
• Splitting a large change into independently verifiable tasks
• Comparing evaluations before and after implementation

Design a persistent multi-agent workflow in Claude Code, with specialist roles, reusable commands, file-based memory, and scheduled tasks. Keep project context and decisions across sessions using JSON and Markdown files without an external database.

• Coordinate specialist agents for development and writing
• Preserve project context across sessions
• Schedule recurring morning briefings

Build a reusable writing style profile from real posts, articles, emails, and product copy. Use it to keep social posts, outreach, and launch announcements consistent in tone, sentence rhythm, and expression across related writing tasks.

• Keep a consistent voice across social channels
• Match outreach emails to an established writing style
• Reuse an author's tone in product announcements

Develop a written brand identity through structured interviews across multiple sessions. Save answers and progress, explore founders' perspectives, and produce a master brandbook that gives designers, writers, and collaborators a shared reference.

• Defining the identity of a new brand
• Revisiting a brand's market positioning
• Preparing a brief for designers and writers

Compare competitors using evidence-backed scores for positioning, brand expression, services, credibility, and other dimensions. Produce consistent profile cards and a two-axis chart showing which rivals occupy the market position your client wants to claim.

• Comparing competitors with consistent scoring criteria
• Preparing evidence-backed competitor profile cards
• Mapping rivals against two strategic goals

Investigate unreliable AI agents across 12 layers, including instructions, memory, tool execution, and display. Use code and logs to trace failures, rank findings by severity, and produce an ordered repair plan that prioritizes code changes.

• Investigating failures that appear only inside an agent application
• Tracing old conversation content leaking into new sessions
• Checking skipped or falsely claimed tool execution

Review Cisco IOS and IOS-XE configurations, choose read-only troubleshooting commands, and plan checks before and after network changes. Examine traffic filtering rules, interface settings, and configuration saving to avoid overlooked operational risks.

• Review router and switch configurations before a change
• Choose read-only commands for troubleshooting
• Check traffic filtering masks and interface direction

Review Claude Code settings for duplicate skills, outdated memory files, unused permissions, and other clutter. The workflow presents evidence for each candidate, requests individual approval, and records reversible cleanup actions.

• Reviewing overlaps after installing many skills
• Checking outdated memory files and unused hooks
• Organizing duplicate permission entries

Add regression tests to AI-assisted code changes so previously found bugs are checked automatically. Test required API fields and sandbox response contracts, then run tests and builds before AI review to catch recurring omissions and inconsistent behavior.

• Add regression tests after fixing a bug
• Check required API response fields
• Review sandbox and production response consistency