Code, minus the dramaCode, minus the drama

Drives Chrome or Chromium through the agent-browser CLI to open pages, fill forms, click buttons, take screenshots and extract data.

Generates an API endpoint with validation, authentication, types and tests, following your project's framework and conventions.

Generates a GraphQL schema with types, queries, mutations, cursor pagination and resolvers for the domain you describe.

Builds a Node.js/TypeScript server linking Telegram, WhatsApp, Instagram and Messenger to the Claude API, with one session per user.

Creates a mock API server with realistic data, error responses and latency, so you can build or test a frontend without the real backend.

Generates a typed client SDK for your API from its OpenAPI spec or route files, with error handling, retries and timeouts.

Builds a Playwright script that logs in, fills forms or downloads files on sites you legitimately have access to.

Builds email automations: parse inbound mail, send templated messages and run sequences with unsubscribe handling and GDPR/CAN-SPAM safeguards.

Builds a workflow to extract text and tables from PDFs, fill forms, merge or split pages, and run OCR on scanned documents.

Turns a hand-made report into a scheduled pipeline that pulls the data, fills a template and delivers it by email or Slack.

Designs scheduled jobs that run on time: picks cron or a queue, and adds retries, locking, monitoring and timezone handling.

Sets up and runs a site-wide crawl with scrape-it-now to get clean markdown, locally or on Azure, with optional indexing.

Builds a scraper on scrapegraph-ai where an LLM extracts data into Pydantic schemas, after checking whether the token cost is worth it.

Automates a spreadsheet with formulas, Google Apps Script or Python (openpyxl/pandas) for reliable imports, validation and calculations.

Builds a scraper that checks robots.txt and terms of service, throttles requests, handles pagination and saves results so runs can resume.

Designs an n8n, Zapier or Make workflow with trigger, steps and error handling, delivered as an n8n JSON export or a build sheet.

Controls your own Chrome, with its logins and cookies, through Midscene Bridge, acting from screenshots rather than the DOM.

Designs a service's autoscaling: scaling metric, bounds, cooldowns and cold-start handling, validated with a load test.

Designs an AWS architecture for your app with a minimal set of services, a Mermaid diagram and a Terraform starter.

Designs an Azure architecture for your app with a minimal set of services, a Mermaid diagram and a Terraform or Bicep starter.

Analyses billing exports and infrastructure code to find wasted spend and returns a prioritised savings plan with estimated monthly savings.

Creates a phased migration plan with an inventory, a 6 Rs strategy per component, cutover and rollback steps, and estimated costs.

Builds a disaster recovery plan: RTO and RPO targets, backup strategy, a failover runbook and a schedule for testing it.

Designs a Google Cloud architecture for your app with a minimal set of services, a Mermaid diagram and a Terraform starter.

Audits IAM policies and writes least-privilege replacements as reviewable code changes, without applying anything itself.

Generates a Mermaid diagram of your infrastructure from Terraform, Kubernetes, docker-compose and other config files.

Builds or converts an app into a serverless HTTP API, with functions, routing, infrastructure code and a local dev loop, without deploying it.

Scans code for smells and anti-patterns, reporting each one's location, severity and a concrete refactoring suggestion.

Measures cyclomatic and cognitive complexity per function, flags those over the thresholds and suggests how to simplify them.

Finds unused imports, variables, functions, files and dependencies, verifies each finding and only removes code after you confirm.

Audits your project's dependencies (npm, pip, Go, Cargo) for known vulnerabilities, unmaintained packages and lighter alternatives, then ranks the actions.

Scans your codebase for duplicated code, shows every location, and suggests a shared abstraction with refactored code, ranked by occurrences and risk.

Audits how your code handles errors, finding swallowed errors, generic catches and poor messages, and suggests concrete improvements.

Reviews variable, function and class names in your code and returns a table of current name, suggested name and the reason for each change.

Refactors the code you point to for quality without changing its behavior, explaining each change with a before and after.

Reviews your changed files or the ones you name, rating issues in correctness, security, performance and maintainability by severity with fix suggestions.

Adds or fixes type annotations in TypeScript/JavaScript and Python code without changing how it behaves at runtime.

Analyzes async/await, promise and concurrency code to find swallowed errors, ordering issues and deadlocks, and proposes the fix.

Builds a three-tier breakpoint plan with file, line, condition and what to check, so you can locate a specific bug quickly.

Stress-tests code with extreme inputs and simulated failures, writes tests per scenario, and rates the bugs it finds by severity.

Adds debug logs at key points of your code to trace a bug, each tagged so it can be removed in one pass once the bug is found.

Analyzes core dumps, segfaults and panics (Go, Rust, JVM, Python) to identify the root cause of a fatal process crash.

Traces a failing request across microservices using correlation IDs to find the service, timeout or retry behind the failure.

Turns a cryptic error code or message into plain English with likely causes, checks to run, fix steps and how to prevent it.

Analyzes your code for memory leak patterns by language (JavaScript, Python, Go and more) and suggests how to fix them.

Diagnoses connection, TLS, HTTP, WebSocket and gRPC failures by reading your network code and explaining the likely cause and fix.

Characterizes a performance bottleneck, inspects the code and generates the profiling commands for your language to build and read flamegraphs.

Investigates bugs that only appear in production using logs, metrics and environment differences, without touching the live system.

Detects race conditions, data races and TOCTOU bugs in your concurrent code and proposes how to fix them.

Analyzes a stack trace or error message, pinpoints the root cause, and explains what happened, why and how to fix it with a code snippet.

Debugs state bugs from UI state (React, Vue, Redux) to caches, sessions and databases, and proposes the fix.

Follows a variable through your codebase from declaration to every read and write to find where its value goes wrong.

Creates or refactors Ansible automation with roles, per-environment inventories, idempotent tasks and secrets encrypted with Ansible Vault.

Generates the continuous integration and deployment config for your project on GitHub Actions, GitLab CI, CircleCI or Jenkins.

Runs a checklist before you ship, covering code quality, security, database and configuration, to catch problems before release.

Generates a docker-compose.yml for local development or production with the services your project needs, health checks and volumes.

Generates or optimizes a multi-stage Dockerfile for your project, with a minimal image, layer caching and a non-root user.

Generates GitHub Actions workflows for CI, CD, auto-labeling and other automation in your repository.

Sets up GitOps for Kubernetes: picks between ArgoCD and Flux, lays out the config repo and defines sync policies and git revert rollbacks.

Creates or improves a Helm chart with clean templates, a values contract, dependencies and a versioning strategy, checked with helm lint.

Generates Kubernetes manifests for your app: Deployment, Service, Ingress, autoscaling and config, as separate YAML files or a Kustomize layout.

Builds an optimized nginx.conf for your project as reverse proxy, SPA host, load balancer or API gateway, with HTTPS, security headers and dev and prod configs.

Finds hardcoded secrets in code and git history, migrates them to a secret manager and sets up a rotation and access plan.

Generates Terraform configurations for AWS, GCP or Azure: resources, variables, outputs, remote state backend and an example tfvars file.

Writes an Architecture Decision Record with context, decision, consequences and alternatives, and saves it under docs/adr.

Compares two versions of your API, classifies changes as breaking, non-breaking or deprecations, and writes migration notes.

Scans your routes and controllers and documents each endpoint with parameters, responses and examples, as Markdown or OpenAPI.

Generates a CONTRIBUTING.md tailored to your project: dev setup, code standards detected from your tooling, and the pull request process.

Reads your code and draws Mermaid diagrams (flowchart, sequence, class, ER, state or C4) with a plain-text explanation.

Documents a file, module or API with overview, usage examples, function reference and configuration, in your project doc format.

Builds an onboarding guide from your actual repo: prerequisites, environment variables, commands and how to get to a first pull request.

Scans your code endpoints and generates or updates an OpenAPI 3.0 YAML spec with schemas, security schemes and examples.

Analyzes your project and writes a complete README.md: description, quick start, installation, usage, configuration and development.

Builds an internal admin panel with CRUD for your models, user impersonation for support, an audit log and server-side role gates.

Implements email and OAuth login, sessions or JWT, role-based access and password reset, extending any auth your app already has.

Sets up a job queue suited to your stack: workers, retries, scheduled jobs and a way to monitor failures.

Adds feature flags to your app: hosted provider or homegrown choice, targeting, kill switches and a cleanup process for old flags.

Implements direct uploads to S3 or R2 with presigned URLs, server-side validation, progress tracking and thumbnails.

Converts your app to multi-tenant: picks the isolation model, enforces tenant scoping and produces migrations and a backfill plan.

Builds in-app, email and optional push notifications filtered by user preferences, with digests to avoid flooding people.

Builds the path from signup to activation: a first-run wizard, checklist, empty states and metrics to see where users drop off.

Integrates payments with Stripe or your existing provider: checkout, subscriptions, signed webhooks and a customer billing portal.

Adds realtime to your app: picks WebSocket, SSE or a managed provider, with presence, optimistic UI and reconnection handling.

Scaffolds a SaaS foundation in your stack: authentication, organizations with invites, billing stubs, settings and transactional email.

Adds search to your app: picks an engine (Postgres, Meilisearch or Elastic), sets up indexing and ranking, and builds a search-as-you-type UI.

Investigates with git blame and log who changed a file or section and why, and presents a timeline of the significant changes.

Creates a well-named branch that follows your team conventions, like type/description or type/TICKET-description.

Generates a CHANGELOG.md from your git history using conventional commits, grouped by version and type of change.

Brings selected commits from a pull request or another branch into your current branch, and helps resolve any conflicts.

Analyzes your staged changes and writes a Conventional Commits message, then creates the commit once you approve it.

Sets up git hooks that lint staged files, validate commit messages and can run fast tests before push, using the hook manager that fits your stack.

Tunes git for a monorepo with sparse checkout, per-package CODEOWNERS and path-filtered CI so changes only build and test what they touch.

Builds a pull request from your commits and diff, with a title, summary, test plan and labels, pushes the branch and returns the PR URL.

Reviews a pull request by number and returns issues with file, line, severity and a suggested fix, ending with approve, request changes or comment.

Works out the next semantic version from your commits, updates CHANGELOG.md, creates the git tag and, if asked, a GitHub release.

Lists your git stashes, previews what each holds and helps you apply, drop, save a new one or branch from a stash, warning about likely conflicts.

Checks your recent history and proposes the safest way to undo the last commit, merge, rebase or change, explaining it before running anything.

Produces a store listing for your app on both stores: keyword research, title and subtitle, descriptions, a screenshot plan and compliance metadata.

Adds Face ID, Touch ID or Android biometrics to your app, with the token held in the platform keystore and a real non-biometric fallback.

Sets up universal links and app links, in-app routing and the server files your web team must host, plus a QA matrix to test every link.

Scaffolds a Flutter app with routing, a confirmed state-management choice, a theme with dark mode and dev, staging and prod flavors.

Designs your app's navigation: stacks, tabs and modals, login-based gating, correct back behaviour and state restoration after the OS kills the app.

Audits app startup, jank, download size, memory and images, measuring before and after and returning a prioritised list of fixes.

Sets up your app's release pipeline: versioning, signing, TestFlight and Play beta tracks, staged rollout and a store-submission checklist.

Makes your app offline-first: picks the local store, defines the sync strategy, resolves conflicts and queues writes so nothing is lost offline.

Implements push notifications with FCM and APNs: platform setup, device token lifecycle, payloads that open the right screen and a better permission prompt.

Scaffolds a production-grade React Native app with Expo: navigation, state, dark-mode theming, environment config, linting and CI.

Designs an API gateway configuration for your API: routing, authentication, rate limits, request validation and observability, plus a matching OpenAPI spec.

Designs CDN cache rules for your web app across static assets, HTML and API responses, including cache keys, purging and ready-to-use headers.

Sets up a Cloudflare D1 (serverless SQLite) database with migrations, wrangler bindings, a typed data access layer and a development seed script.

Configures or audits DNS records for a Cloudflare domain, including A, CNAME, MX, SPF, DKIM and DMARC, proxy settings and verification.

Implements Cloudflare Workers KV for edge key-value storage, with bindings, key design, TTLs and typed helpers, noting KV is eventually consistent.

Configures Cloudflare Pages for your static or JAMstack site: build settings, redirects, headers, optional functions and branch preview deployments.

Sets up Cloudflare R2 storage with upload and download code, S3-compatible access, presigned URLs, CORS and security guidance.

Configures a Cloudflare Tunnel to expose local services without a public IP, with ingress rules, DNS, access policies and deployment options.

Designs Cloudflare WAF and rate-limiting rules based on your app's threat surface, plus a plan to test them without blocking legitimate traffic.

Scaffolds a Cloudflare Worker for your use case, with wrangler.toml, a TypeScript entry point, bindings and staging and production environments.

Diagnoses why a domain fails to resolve or propagate by comparing resolvers and delegation, then proposes specific record changes to fix it.

Implements Cloudflare Durable Objects for stateful use cases such as WebSocket chat rooms, precise counters or locks, with bindings and migrations.

Builds edge functions that rewrite URLs, change headers or validate tokens, on Cloudflare Workers, Vercel Edge Functions or Deno Deploy.

Designs your app's load balancing setup, with origin pools, health checks and failover, as Cloudflare, Nginx or Kubernetes configuration.

Diagnoses timeouts, high latency, refused connections or TLS failures with layered tests, then suggests remediation steps and monitoring.

Generates a reverse proxy configuration for your app on a Cloudflare Worker, Nginx or Caddy, with routing, WebSocket support and security settings.

Audits your site's certificates, TLS versions and HTTPS settings, flags common problems and generates a secure Cloudflare and origin configuration.

Builds an endpoint that receives webhooks with signature verification, duplicate handling and retries, in whichever framework your project uses.

Designs Cloudflare Zero Trust access policies to protect internal apps, and generates the code that validates user identity in your application.

Audits your current alerts and replaces them with a few symptom-based rules, with thresholds, severity and routing, for your monitoring stack.

Creates an incident response process with a severity matrix, roles and communication templates, sized to your team's real scale.

Audits your project's logging and migrates it to JSON logs with levels, correlation IDs, PII redaction and a retention policy.

Adds a small set of application metrics to your app using the RED and USE methods, exported via Prometheus or OpenTelemetry, with cardinality kept in check.

Turns chat logs, alerts and notes from an incident into a postmortem with a timeline, contributing factors and owned action items.

Generates runbooks by reading your code and infrastructure, with symptoms, diagnosis commands, remediation ordered by safety, and escalation.

Defines SLIs and SLOs from your users' key journeys, with error budgets and multi-window burn-rate alerts.

Instruments your service with OpenTelemetry so one request can be followed across services, with auto and manual spans and context propagation.

Analyzes your project's JavaScript bundle size and proposes specific code changes to shrink it, with estimated savings for each.

Designs and implements a caching strategy for API responses, database queries or expensive computations, including invalidation.

Finds your slowest database queries from real data and applies fixes such as indexes, rewritten queries and connection pool changes.

Applies lazy loading to routes, components, images and modules so your site loads faster on first visit.

Scans your frontend and backend code for memory leaks, explains why each one leaks and proposes the fix.

Audits your backend and frontend code for bottlenecks and lists each finding with its location, estimated impact and a specific fix.

Measures your site's LCP, INP and CLS, diagnoses their causes in the code and applies fixes to reach the recommended thresholds.

Drives a browser from the terminal with playwright-cli to open pages, fill forms, take screenshots and extract data.

Generates a React, Vue or Svelte component following your project's conventions, with types, styles, tests and a Storybook story.

Generates a 3D component with React Three Fiber, Three.js or Babylon.js, including types, animations and controls, matched to your project.

Builds a feature end to end: migration, model, API, typed client, UI screens and tests, following your project's conventions.

Generates a custom React hook with types, effect cleanup, error handling, tests and a usage example.

Generates middleware for authentication, authorization, validation, logging, rate limiting or error handling in your project's web framework.

Generates a data model with validation, relationships, serialization, a migration and test fixtures, using whichever ORM your project has.

Generates the full structure of a new project, with config files, Docker, CI and an environment variable template.

Runs 10 parallel agents on your SaaS idea and consolidates market, product, finance and pricing analysis into an investor-ready PowerPoint.

Reviews your app's login, sessions, tokens and access rules and returns severity-rated findings, each with a specific fix.

Reviews your CORS setup in Express, FastAPI, Django or Nginx, tightens overly permissive origins and headers, and verifies them with curl.

Analyzes the scripts, styles, images and connections your app uses and generates a Content Security Policy as a header and a meta tag.

Runs your package manager's audit and lists each vulnerable dependency with its CVE, severity, fixed version and a remediation plan.

Reviews .env files, server settings and HTTP security headers, then generates a hardened configuration with a before and after comparison.

Prepares you for a penetration test: sweeps for easy fixes, documents the scope and delivers a pentest-prep.md with a checklist and known risks.

Designs and adds rate limiting: picks an algorithm, sets per-route budgets, returns 429 with Retry-After and adds tests.

Traces where user input enters your code and where it ends up, flags SQL injection, XSS and similar flaws, and proposes the fix.

Scans your code, config files and recent git history for API keys, tokens, passwords and private keys, and explains how to remediate each.

Audits your codebase against the OWASP Top 10 and returns each finding with severity, file and line, a description and a fix.

Analyzes your repo's architecture and writes threat-model.md with a data-flow diagram, rated STRIDE threats and a top-5 action list.

Audits your site's technical, on-page and content SEO and delivers a report with issues, impact, fixes and a prioritized action plan.

Sets up consumer-driven contract tests (Pact by default) so breakages between services are caught at build time without running both together.

Sets up load tests with k6, Locust or Artillery: realistic scenarios, pass/fail thresholds and a lightweight smoke gate in CI.

Sets up mutation testing to measure whether your tests would catch real bugs, then turns surviving mutants into stronger tests.

Drives a real browser through Playwright MCP to navigate, click, fill forms, debug pages and take screenshots.

Reviews failing test snapshots and decides whether each is an intended change, a real bug or a flaky test before updating anything.

Finds which code your tests don't cover, ranks the gaps by risk and generates tests for the highest-priority ones.

Generates end-to-end tests for a user workflow in Playwright, Cypress or similar, covering happy path, error paths and data cleanup.

Generates tests for boundaries, nulls, concurrency, Unicode and state in your code, explaining which bug each one would catch.

Runs your test suite, works out whether each failure is in the test, the code or the environment, fixes it and re-runs to confirm.

Reads a file and writes unit tests covering normal use, edge cases and errors in your existing framework, then runs them to check they pass.

Generates integration tests that exercise real interactions between components, APIs and databases, including partial failures and retries.

Creates mocks, stubs, spies, fakes and realistic fixture data for your code's dependencies, following Jest, Vitest, pytest or Go conventions.

Sets up screenshot comparison against approved baselines to catch unintended UI changes, with CI integration and flakiness control.

Builds a benchmark with warmup, repetition and statistics to measure or compare performance, optionally with a CI regression gate.

Converts data between JSON, YAML, TOML, XML, CSV and ENV, or into TypeScript interfaces, JSON Schema or Zod, and validates the output.

Turns a schedule description into a cron expression, or explains an existing one in plain English, with the next 5 run times and common pitfalls.

Lists outdated dependencies, sorts them into patch, minor and major, checks breaking changes and updates in batches, running tests.

Finds every environment variable your code uses and generates a .env.example, a validation schema and a config module that fails fast.

Generates or tunes your ESLint config for TypeScript, React or Node, with rules, ignores, lint scripts and a pre-commit hook.

Reads the code you point to and explains it in layers: summary, purpose, step-by-step flow, key concepts, dependencies and gotchas.

Detects your project languages, frameworks and tools, then writes a commented .gitignore, merging with any existing one.

Validates, diffs, queries with jq, flattens or infers a schema for JSON, and returns the result on screen or in a file.

Sets up or tunes a monorepo with workspaces, shared configs, cached builds and tests that run only on affected packages.

Reviews and tidies your package.json: scripts, dependencies, metadata and config, and flags risks such as postinstall scripts.

Writes, explains and tests regular expressions in your language, with test cases and warnings about ReDoS and flavor differences.

Translates code from one programming language to another, keeping the logic, using target idioms and noting what has no direct equivalent.

Generates or tunes tsconfig.json for a backend, frontend, library or monorepo, with strict mode and an explanation of the settings.

A guide for writing, reviewing or migrating Swift 6: value types, data-race-safe concurrency, protocols, performance and Swift Testing.