Jobs agents do on Rush

Summarize Each Customer's Product Usage From PostHog Through an API: Yes. Your backend starts one session per account; the agent reads that account's PostHog events and returns a JSON usage summary to your webhook.
Add an Output to a Custom GitHub Action from a Linear Issue: Yes. An agent reads your Linear issue, adds a duration-ms output to your TypeScript GitHub Action with a test, and opens a pull request.
Add API Rate Limiting to a Laravel App from a Linear Issue: Yes. An agent picks up the Linear issue, adds API rate limits to your Laravel routes, tests them with PHPUnit and opens a pull request.
Add Rate Limiting to a Phoenix API from a Linear Issue: Yes. An agent picks up the Linear issue, adds a rate limit plug to your Phoenix API, tests it with ExUnit against Postgres and opens a pull request.
Add Article Search to a SvelteKit App from a Linear Issue: Label a Linear issue and an agent adds a shareable ?q= article search to your SvelteKit app, with tests, a green build, and a pull request linking the issue.
Add a Launch at Login Setting to an Electron App from a Linear Issue: Yes. An agent reads the issue, adds a launch at login toggle to your Electron app over IPC with tests, and opens a pull request that links back to it.
Add a Bulk Export Action to a Filament Table from a Linear Issue: Yes. An agent reads the Linear issue, adds an admin-only CSV bulk export to your Filament orders table, covers it with Pest tests and opens a pull request.
Add Chat History Export to a Streamlit App from a Linear Issue: Yes. An agent reads the Linear issue, adds an st.download_button that saves the conversation as Markdown, tests it with AppTest and opens a pull request.
Add CloudWatch Alarms to an AWS CDK Stack: Yes. An agent adds CloudWatch alarms on the Lambda, API Gateway and DynamoDB metrics in your CDK stack, asserts them in a test, synthesizes and opens a pull request.
Add a Context Menu Item to a Chrome Extension from a Linear Issue: Yes. An agent reads the labeled issue, adds the contextMenus permission, a background handler and popup view, with tests, and opens a pull request.
Add CORS and Rate Limiting to a Ktor Server from a Linear Issue: Yes. An agent reads the labeled Linear issue, adds Ktor's CORS and RateLimit plugins to the kweet sample with tests, and opens a pull request linked to the issue.
Add Test Coverage Reporting to ASP.NET Core CI: Yes. An agent measures your .NET solution's coverage in its sandbox, merges the test projects into one report, adds a threshold to CI and opens a pull request.
Add Test Coverage Reporting to Go CI: A Rush agent measures your Go coverage in its sandbox, adds a threshold at that number and a coverage artifact to CI, and opens a pull request with passing checks.
Add Test Coverage Reporting to Nuxt CI: Yes. An agent runs your Nuxt unit tests with v8 coverage, adds a threshold and a coverage artifact to the GitHub Actions workflow, and opens a pull request.
Add Test Coverage Reporting to Python CI: Yes. An agent measures your pytest coverage in a sandbox, adds it to your GitHub Actions test job with that number as the floor and opens a pull request.
Add Test Coverage Reporting to Rust CI: Yes. An agent measures your Rust crate's line coverage with cargo-llvm-cov, adds a CI job with a threshold at that number and an lcov artifact, and opens a PR.
Add CSV Export to a Django App from a Linear Issue: Label a Linear issue and an agent adds a members-only CSV export of your project's checks to your Django app, with tests and a pull request.
Add a CSV Export to a Symfony Admin Backend from a Linear Issue: Yes. An agent reads the labelled Linear issue, adds a CSV export route to the Symfony admin controller with a PHPUnit test, and opens a pull request.
Add CSV Export to a Wagtail Admin: Yes. An agent adds CSV and XLSX export to your Wagtail snippet listings and a page report, writes tests, runs the suite and lint, and opens a pull request.
Add Cursor Pagination to a Django REST Framework API from a Linear Issue: Yes. An agent reads the issue, adds a CursorPagination class beside your limit-offset one, switches the endpoints the issue names, writes tests and opens a PR.
Add Cursor Pagination to a Gin API from a Linear Issue: Yes. An agent reads the labelled Linear issue, adds an opaque cursor to a Gin API's list endpoints beside offset paging, tests it, and opens a pull request.
Add Custom Span Attributes with OpenTelemetry from a Linear Issue: Yes. An agent picks up the Linear issue, adds app.order.amount and app.order.items.count on the PlaceOrder span, tests them and opens a pull request.
Add a Customer Lifetime Value Model to a dbt Project from a Linear Issue: Yes. An agent picks up the Linear issue, adds a customer lifetime value mart to your dbt project with YAML tests and opens a pull request.
Add Dark Mode to an Angular App: Yes. Your team can watch an agent add dark mode to an Angular app, correct the screenshots, and get a pull request that follows the system theme.
Add Dark Mode to an Electron App: Yes. An agent adds a system, light and dark setting to an Electron app through nativeTheme, a menu and a toggle, with Jest tests, steered by follow-ups.
Add Dark Mode to a Gatsby Blog: Yes. An agent adds a dark theme to your Gatsby blog's CSS variables, a toggle that persists, and a no-flash script, then builds and screenshots it.
Add Dark Mode to a SvelteKit App: Yes. Teammates can watch an agent add a remembered dark theme to a SvelteKit app and correct contrast before the pull request opens.
Add a Dark Mode Toggle to a Vite React App from a Linear Issue: Yes. An agent picks up the Linear issue, adds a dark mode toggle to your Vite React app's header with Vitest tests, and opens a pull request.
Add Dark Mode to a Vue App: Yes. A team can watch an agent add dark mode to a Vue app, check contrast in the browser, and steer the theme before the pull request.
Add a Dark Theme Setting to a Flutter App from a Linear Issue: Yes. An agent picks up the Linear issue, wires system, light and dark theme options on settings, persists them and opens a pull request.
Add a Dead Letter Queue to a Lambda in AWS CDK from a Linear Issue: Yes. An agent picks up the Linear issue, gives each Lambda an SQS dead letter queue and a CloudWatch alarm, with assertion tests, and opens a pull request.
Add a Feature to a Flask App from a Customer Spec: Yes. Your product sends the customer's spec in one API call; an agent builds it in their Flask repo with tests and opens a pull request.
Add a Feature to a Gin App from a Customer Spec: Yes. Your product sends the customer's spec to the API, and an agent builds the feature in their Gin repo, adds Go tests and opens a pull request.
Add a Feature to a Phoenix App from a Customer Spec: Yes. Your product sends the spec to the API, and an agent builds the feature in the customer's Phoenix LiveView app, tests it and opens a pull request.
Set Up GitHub Actions CI for an Express App: Yes. An agent reads your Express repo, adds a GitHub Actions workflow that lints, tests against Postgres and builds, and fixes it until it passes.
Set Up GitHub Actions CI for a Flask App: Yes. An agent reads your Flask repo, adds a GitHub Actions workflow that installs the pins, compiles translations and runs the tests, and fixes it until green.
Set Up GitHub Actions CI for a Gatsby Site: Yes. An agent reads your Gatsby site's scripts and lockfile, writes a workflow that installs, checks formatting and builds with a cache, and opens a pull request.
Set Up GitHub Actions CI for a Next.js App: Yes. An agent reads your Next.js repo, adds a GitHub Actions workflow with pnpm caching, lint and type checks, and fixes it until it passes.
Set Up GitHub Actions CI for a React Router App: Yes. An agent reads your React Router 7 app's scripts, Node version and lockfile, adds a workflow that typechecks and builds it, and opens a pull request.
Set Up GitHub Actions CI for a SvelteKit App: Yes. An agent reads your SvelteKit repo, adds a GitHub Actions workflow with pnpm caching, Prettier, svelte-check and the build, and fixes it until it passes.
Add Graceful Shutdown to a Go Service from a Linear Issue: Label a Linear issue and an agent adds deadline-bounded graceful shutdown across your Go service's HTTP, gRPC and message servers, with tests.
Add Graceful Shutdown to a Rust Axum Service: Yes. An agent makes your Axum service finish in-flight requests on SIGTERM, close its Postgres pool and exit within a deadline, with a test, and opens a PR.
Add Health Checks to an ASP.NET Core App from a Linear Issue: Yes. An agent picks up the Linear issue, adds liveness and readiness checks to your ASP.NET Core app, tests them and opens a pull request.
Add Health Checks to a Docker Compose Setup: Yes. An agent reads each image for a probe tool, adds a healthcheck and a service_healthy dependency per service, proves it with compose up and opens a PR.
Add Health Checks to an Express API: Yes. An agent adds liveness and readiness routes to your Express API, checks Prisma in the ready route, tests both with Jest and opens a pull request.
Add Health Check Endpoints to a Gin App: Yes. An agent adds liveness and readiness endpoints to your Gin service, the readiness one pinging the database with a timeout, with tests, and opens a pull request.
Add Health Checks to a NestJS API: Yes. An agent adds liveness and readiness routes to your NestJS API with Terminus, checks the database in the ready route, tests both end to end and opens a PR.
Add Health Checks to a Phoenix App: Yes. An agent adds liveness and readiness endpoints to your Phoenix app, checks the database behind the readiness one, writes ExUnit tests, and opens a PR.
Add Health Checks to a Quarkus Service: Yes. An agent adds SmallRye Health to a Quarkus service with a readiness check on its database, tests the /q/health endpoints, and opens a pull request.
Add Health Checks to a Symfony App: Yes. An agent adds live and ready routes outside your Symfony app's locale prefix, checks Doctrine in the ready route, tests both and opens a pull request.
Add Health Checks to a Wagtail Site: Yes. An agent adds django-health-check to a Wagtail site with database and cache checks, a /health/ route, a Django test and a Docker HEALTHCHECK, and opens a PR.
Add Horizontal Pod Autoscalers to Kubernetes Manifests from a Linear Issue: Yes. An agent reads the labelled Linear issue, adds a Kustomize component with one HPA per stateless Deployment, renders and validates it, and opens a PR.
Add a Second Language to an Astro Site: Yes. An agent adds a locale to your Astro site's i18n config, writes the UI strings, creates the localised routes and switcher, builds it and opens a pull request.
Add i18n to a React App from a Linear Issue: Yes. An agent reads the labelled Linear issue, wires i18next into a Vite React app, moves strings into locale files, adds a switcher and tests, and opens a PR.
Add i18n to a Vue 3 App from a Linear Issue: Yes. An agent reads the labelled Linear issue, adds vue-i18n, moves template strings into locale files, adds a switcher, keeps the e2e suite green, and opens a PR.
Add Request Validation to a Serverless API from a Linear Issue: Yes. An agent picks up the Linear issue, validates create and update bodies with JSON Schema, returns 400 with field errors and opens a pull request.
Expire Team Invitations After 7 Days in a Next.js App from a Linear Issue: Label a Linear issue and an agent makes team invitations expire after 7 days in your Next.js app, with a Drizzle migration, tests, and a pull request.
Add JSON Output to a Rust CLI from a Linear Issue: Yes. An agent picks up the Linear issue, adds a --json flag to zoxide query that prints path and score, documents it and opens a pull request.
Add JWT Auth to a Hono API from a Linear Issue: Yes. An agent picks up the Linear issue, protects your Hono API's write routes with Hono's jwt middleware, adds tests and opens a pull request.
Add JWT Authentication to a Vapor App from a Linear Issue: Yes. An agent reads the issue, adds a User model, login route and JWT bearer middleware to your Vapor app, writes Swift Testing tests and opens a PR.
Add KV Caching to a Cloudflare Worker from a Linear Issue: Yes. An agent picks up the Linear issue, caches the D1 list query in KV for 60 seconds, invalidates on write and opens a pull request.
Add Model Contracts to a dbt Project: Yes. An agent enforces contracts on your dbt marts, lists every column with its data type in the model YAML, checks parse and build, and opens a pull request.
Add a NetworkPolicy Option to a Helm Chart from a Linear Issue: Yes. An agent picks up the Linear issue, adds a NetworkPolicy option with configurable ingress sources, unit tests and a chart version bump.
Add OpenAPI Docs to an Actix Web API: Yes. An agent annotates your Actix Web handlers and models with utoipa, serves openapi.json and Swagger UI, tests the document, and opens a pull request.
Serve OpenAPI Docs from a Fastify API from a Linear Issue: Yes. An agent picks up the Linear issue, serves an OpenAPI document built from your Fastify route schemas, tests that it lists every route and opens a PR.
Add OpenAPI Docs to a Flask API from a Linear Issue: Yes. An agent picks up the Linear issue, writes an OpenAPI document for your Flask blueprint, serves Swagger UI, tests that every route is listed and opens a PR.
Add OpenAPI Docs to a Gin API: Yes. An agent annotates your Gin handlers with swag comments, generates the OpenAPI spec, serves Swagger UI, checks it against the real routes and opens a PR.
Add OpenAPI and Swagger UI to a Quarkus Service from a Linear Issue: Yes. Send the Linear issue text to Rush and an agent adds OpenAPI descriptions, examples and endpoint tests in a reviewable Quarkus pull request.
Add OpenTelemetry Tracing to an Express Service: Yes. An agent instruments your Express service with OpenTelemetry for HTTP, Prisma and outbound calls, then exports real traces to a collector to prove it.
Add OpenTelemetry Tracing to a FastAPI Service: Send Rush a FastAPI repository to add OpenTelemetry spans for HTTP, database and outbound calls, and get a pull request with exported traces.
Add OpenTelemetry Tracing to a Gin API: Yes. An agent adds OpenTelemetry to your Gin API with the otelgin middleware and the GORM tracing plugin, proves spans appear for real requests, and opens a PR.
Add OpenTelemetry Tracing to a Go Service: Send Rush a Go repository to add OpenTelemetry spans for HTTP, database and outbound calls, and get a pull request with exported traces.
Add OpenTelemetry Tracing to a NestJS Service: Yes. An agent adds the OpenTelemetry Node SDK to your NestJS service for HTTP, Express and the database, exports a real trace to a collector, and opens a PR.
Add OpenTelemetry Tracing to a Phoenix App: Yes. An agent wires OpenTelemetry into your Phoenix endpoint, Ecto repo and Oban jobs, exports over OTLP, and opens a pull request that compiles clean.
Add Optimistic UI to a React Router Form from a Linear Issue: Yes. An agent picks up the Linear issue, makes form submission update the list immediately with useFetcher, rolls back on failure and opens a pull request.
Add Cursor Pagination to a FastAPI Endpoint from a Linear Issue: Yes. Label the Linear issue and an agent adds cursor pagination to the FastAPI endpoint, runs pytest against Postgres and opens a pull request linked to the issue.
Rate Limit Password Reset in a Flask App from a Linear Issue: Yes. An agent picks up the Linear issue, rate limits password reset to 3 requests per email per hour with Flask-Limiter and opens a pull request.
Persist Pinia State in a Vue App from a Linear Issue: Yes. An agent turns your Linear issue into a Vue pull request that persists the user's name and language, with reload and clear-state tests.
Add Pod Disruption Budgets to Kubernetes Manifests from a Linear Issue: Yes. An agent reads your rendered Kubernetes workloads and proposes opt-in disruption budgets with selector checks and Kustomize validation.
Schedule Posts for Later in a Symfony App from a Linear Issue: Yes. An agent reads the Linear issue, hides future-dated posts everywhere readers can reach them, marks them scheduled in the admin and opens a pull request.
Add Pull to Refresh to a React Native List from a Linear Issue: Yes. Send the issue to Rush and an agent adds pull to refresh through your existing query, with loading-state tests and a React Native PR.
Add PWA Support to an Angular App: Yes. An agent adds the Angular service worker and a web app manifest to a standalone Angular app, caches the fonts it loads, builds it, and opens a pull request.
Add PWA Support to a SvelteKit App: Yes. An agent adds a SvelteKit service worker, completes the manifest and theme colour, builds the app, checks it offline in a browser and opens a pull request.
Add Rate Limiting to an ASP.NET Core API: Yes. An agent adds the built-in rate limiter middleware to your ASP.NET Core API, a strict policy on login and registration, tests for the 429 path, and opens a PR.
Add Rate Limiting to a Cloudflare Worker: Yes. An agent adds a Workers rate limiting binding, a Hono middleware that answers 429 past the limit and a Vitest case that proves it, then opens a pull request.
Add Rate Limiting to an Express API from a Linear Issue: Yes. An agent picks up the Linear issue, adds per-route rate limits to your Express API, proves them with Jest tests and opens a pull request.
Add Rate Limiting to a FastAPI API: Yes. An agent adds a rate-limit dependency to the login, signup and password-reset routes of your FastAPI app, proves the 429 with pytest and opens a pull request.
Add Rate Limiting to a Hono API from a Linear Issue: Yes. An agent reads the labelled Linear issue, adds a rate-limit middleware to a Hono Worker's API routes with Vitest tests, and opens a pull request.
Add Rate Limiting to a Quarkus REST API: Yes. An agent adds SmallRye Fault Tolerance rate limits to your Quarkus REST endpoints, maps rejections to 429 with Retry-After, proves it with a test, opens a PR.
Add Rate Limiting to a Symfony App: Yes. An agent adds login throttling and request limiters to your Symfony app with the RateLimiter component, writes functional tests, runs the suite and opens a PR.
Add Reading Time to Posts in an Astro Site from a Linear Issue: Yes. An agent picks up the Linear issue, adds build-time reading time next to each Astro post date, runs the build and opens a pull request.
Add Request ID Logging to a FastAPI App: Yes. An agent adds a request ID middleware to your FastAPI app, threads the ID through every log line and the response header, tests it, and opens a PR.
Add Request IDs and Structured Logging to a Gin API from a Linear Issue: Yes. An agent picks up the Linear issue, adds request IDs and structured JSON logging to your Gin API, runs go test and opens a pull request.
Add Request Tracing to an Axum API from a Linear Issue: Yes. An agent picks up the Linear issue, adds TraceLayer request tracing to your Axum API, runs cargo test and opens a pull request.
Add Resource Requests and Limits to a Kustomize App from a Linear Issue: Yes. An agent reads the issue, finds every container in your Kustomize app without resources, adds requests and limits, validates the render and opens a PR.
Add a REST API to a Spring Boot App from a Linear Issue: Yes. An agent picks up the Linear issue, adds JSON owner endpoints under /api/owners to your Spring Boot app, runs verify and opens a pull request.
Add Row Level Security Policies to a Supabase Project from a Linear Issue: Yes. An agent picks up the Linear issue, writes row level security policies as a Supabase migration, tests them and opens a pull request.
Add a Route Guard for Unsaved Changes in an Angular App from a Linear Issue: Yes. An agent reads your Angular editor and adds a tested CanDeactivate guard that asks before discarding unsaved article changes.
Add Security Headers to a Node.js App: Yes. An agent adds helmet with a content security policy fitted to your templates, hardens the session cookie, checks every page still works and opens a PR.
Add Shell Completion to a Go CLI from a Linear Issue: Yes. An agent picks up the Linear issue, documents and tests Cobra shell completion for your Go CLI, runs go test and opens a pull request.
Add a Single-Instance Lock to an Electron App: Yes. An agent adds requestSingleInstanceLock to your Electron main process so a second launch focuses the window, with a unit test, lint and a smoke run.
Add a Sitemap to a Gatsby Blog: Yes. An agent adds gatsby-plugin-sitemap to your Gatsby 5 blog, points robots.txt at the index it generates, builds the site to check it and opens a pull request.
Add an Audit Log to a NestJS API from a Linear Issue: Yes. An agent turns the issue into a NestJS PR with user-change audit records, an admin-only read endpoint and database-backed tests.
Add Live Search to a Phoenix LiveView Page from a Linear Issue: Yes. An agent picks up the Linear issue, adds debounced live song search on your Phoenix LiveView profile page, runs mix test and opens a pull request.
Add a Staging Overlay with Kustomize from a Linear Issue: Yes. An agent picks up the Linear issue, adds a Kustomize staging overlay for guestbook plus an Argo CD Application, validates it and opens a pull request.
Add Stripe Checkout to a Django App: Yes. An agent adds a Stripe Checkout endpoint and a signature-checked webhook to your Django app, tests it in Stripe test mode and opens a pull request.
Add Stripe Checkout to an Express App: Yes. An agent adds a Checkout Session route and a signature-checked webhook to your Express app, tests both with the Stripe CLI and opens a pull request.
Add Stripe Checkout to a Rails App: Yes. An agent adds a Checkout controller and a verified Stripe webhook to your Rails app, tests them with the Stripe CLI and opens a pull request.
Add Throttling to a Django REST Framework API from a Linear Issue: Yes. An agent reads the Linear issue, adds DRF anonymous, user and login throttles to your settings and views, proves them with pytest and opens a pull request.
Add Pagination to a Vapor API from a Linear Issue: Yes. An agent picks up the Linear issue, paginates GET /todos in your Vapor API with Fluent, runs swift test and opens a pull request.
Add Type Hints to a Flask Codebase: Yes. An agent annotates every function in your Flask app, configures mypy in strict mode, reaches zero errors without changing behaviour, and opens a PR.
Add Type Hints to a Wagtail Codebase: Send Rush a Wagtail repository to add type hints across the code, get mypy strict passing, and receive a pull request with its output.
Add Muting Users to a Rails App from a Linear Issue: Yes. An agent picks up the Linear issue, adds user muting so stories and comments hide everywhere, runs RSpec and opens a pull request.
Add a values.schema.json to a Helm Chart: Yes. An agent writes a JSON Schema for your chart's values.yaml, validates it against every ci values file with helm lint, bumps the version and opens a PR.
Add Variable Validation to a Terraform Module from a Linear Issue: Yes. An agent adds tested Terraform variable checks so invalid S3 inputs produce useful diagnostics before infrastructure changes.
Add a Watchlist Page to a Nuxt App from a Linear Issue: Yes. An agent adds a browser-stored movie watchlist to your Nuxt app, reuses its media cards and returns a PR with persistence tests.
Add a New Page Type to a Wagtail Site from a Linear Issue: Yes. An agent picks up the Linear issue, adds a WorkshopPage type to your Wagtail site with a migration and tests, then opens a pull request.
Find Noisy Grafana Alerts: An agent reads Grafana alert rules and available firing history, then returns a ranked noise audit with queries and proposed changes.
Address Review Comments on a Laravel Pull Request: Yes. An agent reads the review comments on your Laravel pull request, fixes each one on the same branch, runs the tests, and replies on the thread.
Address Review Comments on a Rails Pull Request: Yes. An agent reads the review comments on your Rails pull request, fixes each one on the same branch, runs the tests, and replies on the thread.
Answer Support Tickets from a Django Codebase: Yes. Your backend sends each ticket to the API, an agent reads your Django code for the cause, and the reply comes back as JSON on your webhook.
Answer Support Tickets from a Go Codebase: Yes. Your backend sends each ticket to the API, an agent traces the behaviour through your Go code, and the reply comes back as JSON on your webhook.
Answer Support Tickets from a PocketBase Codebase: Yes. Your backend sends each ticket to the API, an agent traces the answer through your PocketBase Go code, and a typed JSON reply comes back on your webhook.
Answer Support Tickets from a Rails Codebase: Yes. Your backend sends each ticket to the API, an agent finds the rule in your Rails models, and the reply comes back as JSON on your webhook.
List Every API Endpoint in an ASP.NET Core App: An agent traces ASP.NET Core route registration, authentication and request models, then checks local responses and writes an endpoint inventory.
List Every API Endpoint in an Express App: An agent follows Express router mounts and auth middleware, probes a disposable local server, and returns a route and parameter inventory.
List Every API Endpoint in a FastAPI App: An agent traces FastAPI routers, dependency-based auth and request models, then checks local responses and returns a cited endpoint table.
Inventory the API Endpoints of a Gin Service: Yes. An agent reads your Gin router groups and middleware order and writes a table of every endpoint with its handler, auth rule, parameters and tests.
List Every API Endpoint in a Phoenix App: Yes. An agent reads a Phoenix router scope by scope, maps each API route to its pipeline, auth plug and controller, checks the OpenAPI spec and returns a table.
List Every API Endpoint in a Rails App: An agent expands Rails routes, traces controller callbacks and API-key checks, then writes an endpoint inventory with local verification limits.
Explain the Architecture of an ASP.NET Core Solution: Yes. An agent reads an ASP.NET Core solution from its Aspire AppHost to each service, traces one order end to end, and returns a cited architecture document.
Explain the Architecture of a Django Codebase: Yes. An agent reads a Django codebase and returns architecture.md with the request path, data model, jobs and a diagram, citing files.
Explain the Architecture of an Elixir Codebase: Yes. An agent reads an Elixir codebase and returns architecture.md with the request path, schemas, Oban jobs and a diagram, citing files.
Explain the Architecture of a Go Codebase: An agent reads a Go codebase, follows a request to storage, and returns an architecture document with Mermaid diagrams and source references.
Explain the Architecture of a Rails Codebase: An agent traces Rails routes, models, storage and jobs, then returns a source-linked architecture document with diagrams and a request walkthrough.
Explain the Architecture of a Spring Boot Codebase: An agent reads a Spring Boot codebase, follows one request from controller to JPA repository, and returns an architecture document with diagrams and file references.
Turn an Asana Task into a Pull Request for a Laravel App: Yes. An agent reads the Asana task, does the work in your Laravel repo with PHPUnit tests, opens a PR and comments the link back on the task.
Turn an Asana Task into a Pull Request for a Next.js App: Yes. An agent reads the Asana task, builds it in your Next.js repo with a test, opens a pull request and posts the link as a comment on the task.
Audit a Django Repository per Customer Request: Your backend sends one API request per customer repo; an agent runs its Django tests and posts JSON on stale packages, test results and risky code to your webhook.
Audit a Laravel Repository per Customer Request: One API call per customer: an agent runs the Laravel app's PHPUnit suite, checks Composer for stale majors and returns a JSON audit to your webhook.
Audit a Next.js Repository per Customer Request: Send each customer's Next.js repo to an agent with one API call and get back JSON on outdated packages, build and test results, and risky code, by webhook.
Audit a Rails Repository per Customer Request: Start one agent per customer Rails repo with an API call; it runs the Minitest suite, checks gems for stale majors and returns a JSON audit by webhook.
Audit SaaS Subscriptions in Ramp: Yes. An agent reads Ramp transactions, cards, reimbursements and bills, and returns saas-audit.md flagging duplicate vendors and price jumps.
Build a Backlink Report With Ahrefs: An agent reads available Ahrefs referring-domain, backlink and anchor data, then returns a monthly report with evidence for reclamation work.
Triage a Stale Jira Backlog: Yes. An agent reads Jira issues untouched for 90 days and returns triage.md proposing close, merge or keep, without changing a single issue.
Find Broken Backlinks With Ahrefs: Yes. An agent reads Ahrefs backlinks that land on 404 pages and returns a CSV of redirect targets plus a short summary.
Build an Admin Page in a Django App: An agent builds an admin-only Django page for failed donation attempts, with date filters, permission tests and browser screenshots for team review.
Build an Admin Page in a Laravel App: An agent adds a Laravel admin page for reported threads, with a protected resolve action, permission tests and browser evidence your team can review.
Build an Admin Page in a Phoenix App: Yes. An agent adds an admin-only LiveView of listener counts per profile, with tests and browser screenshots, while teammates follow the run.
Build an Admin Page in a Rails App: An agent builds a Rails admin view of slow background jobs, checking the available timing data first and returning tests and browser screenshots.
Build an Onboarding Flow in a Next.js App with Your Team: Yes. Your product team can watch an agent build a three-step signup flow in Next.js and correct the copy before the pull request.
Find Slow Vercel Builds: An agent compares Vercel deployment timings and available build logs, then returns a report separating slow phases from queue time and missing evidence.
Report Email Campaign Performance From Klaviyo: Yes. An agent reads Klaviyo campaigns from the last 90 days and writes campaigns.md ranked by revenue per recipient.
Find Why Customers Churned in Stripe: Yes. An agent reads your cancelled Stripe subscriptions and writes churn.md, grouping churn by reason, plan and tenure and splitting failed payments from choices.
Estimate Cloud Costs for a Terraform Deployment: Yes. An agent reads a Terraform VPC example, prices each resource from AWS's public pages, and writes costs.md.
Compare Express 5 and Hono for an Express Project: Yes. An agent ports one module of your Express app to Express 5 and to Hono in a sandbox, runs tests and a benchmark on each, and writes up the difference.
Compare Drizzle and Prisma for a Next.js Project: Yes. An agent ports your Next.js app's queries between Drizzle and Prisma in a sandbox, checks both return the same data, times them and writes up the difference.
Compare Competitor Traffic With Semrush: Yes. An agent reads six months of Semrush traffic estimates for your site and two competitors and returns traffic.md comparing visits, channels and top pages.
Write an SEO Content Brief With Semrush Data: Yes. Give an agent a keyword and it reads Semrush data and the top 10 ranking pages, then returns brief.md with an outline, terms and questions to cover.
Find Content Gaps With Ahrefs: Yes. An agent reads top pages for your domain and two competitors through your Ahrefs connection and returns content-gap.md ranked by traffic.
Convert React Class Components to Hooks: Yes. An agent converts your React class components to function components with hooks, one per commit, runs the tests after each and opens a pull request.
Convert an Express App from JavaScript to TypeScript: Yes. An agent converts your Express app to strict TypeScript layer by layer in a sandbox, keeps the Jest suite green, and opens a pull request with the tsc output.
Convert a Gatsby Site From JavaScript to TypeScript: Yes. An agent converts a Gatsby site's config, pages, templates and components to TypeScript with typed props and query data, builds it and opens a pull request.
Convert a Node.js App from JavaScript to TypeScript: Yes. An agent converts your Node.js app to strict TypeScript one directory at a time in a cloud sandbox and opens a pull request with the tsc output.
Convert a SvelteKit App from JavaScript to TypeScript: Yes. An agent converts your SvelteKit app's load functions, actions, hooks and components to TypeScript, adds svelte-check, and opens a pull request with it passing.
Convert a Vue App From JavaScript to TypeScript: Yes. An agent adds TypeScript to your Vue 3 app, converts stores, services, router and components file by file, and opens a pull request that type-checks.
Write a Linear Cycle Report: An agent reads a Linear cycle, issue history and available comments, then returns a report on completion, rollover, scope changes and blockers.
Get a Daily Sales Summary From Square: Yes. An agent reads yesterday's Square orders and writes a one-page sales summary next to the same weekday a week earlier.
Review a Supabase Database Schema: Yes. An agent reads your Supabase schema and table stats through the connection and returns schema-review.md with index, bloat and type fixes as SQL you did not run.
Document dbt Models and Find Data Quality Gaps: Yes. An agent builds dbt-labs/jaffle-shop on DuckDB in a sandbox and writes models.md, flagging untested join and metric columns.
Debug a Front-End Bug in a Nuxt App Together: An agent reproduces your team's Nuxt browser demonstration, traces the failing state, and returns a focused fix with a regression test and screenshots.
Debug a Front-End Bug in a React App Together: An agent follows your team's React browser reproduction, fixes the responsible interaction, and returns a pull request with tests and visual evidence.
Report Failed Vercel Deployments Across Projects: Yes. An agent reads two weeks of deployments across your Vercel team, groups failures by build-log error and returns deployments.md with the top causes.
Summarize Open PayPal Disputes: Yes. An agent reads open PayPal disputes and writes disputes.md with the amount, reason, deadline and evidence requested.
Dockerize an Angular App: Yes. An agent builds your Angular app in a Bun stage, serves the output from nginx with a single-page fallback, checks deep links in a sandbox and opens a PR.
Dockerize an Axum API With SQLx and Postgres: Yes. An agent writes a multi-stage Dockerfile and a Compose file for your Axum API, handles SQLx's compile-time query checks, boots the stack and opens a PR.
Dockerize a Fastify App With MySQL: Yes. An agent writes a multi-stage Dockerfile for your TypeScript Fastify app, adds it to Compose beside MySQL with a health check, boots the stack and opens a PR.
Dockerize a Gin API: Yes. An agent writes a multi-stage Dockerfile and compose file for your Gin API, builds it with the SQLite driver's cgo, boots it in a sandbox and opens a PR.
Dockerize a Ktor Server: Yes. An agent reads your Ktor build, writes a multi-stage Dockerfile around the fat jar, adds the app to Compose next to Postgres, and proves it answers.
Dockerize a Laravel App: Yes. An agent writes a multi-stage Dockerfile and compose.yaml for your Laravel app, boots it with its database in a sandbox and opens a pull request.
Dockerize a NestJS App: Yes. An agent reads your NestJS build setup, writes a multi-stage Dockerfile and compose file, starts the container in a sandbox and opens a pull request.
Dockerize a Next.js App: Yes. An agent writes a standalone multi-stage Dockerfile and a compose.yaml with Postgres for your Next.js app, boots it in a sandbox and opens a PR.
Dockerize a Nuxt App: Yes. An agent writes a multi-stage Dockerfile and compose file for your Nuxt app, builds the Nitro output, boots it in a sandbox and opens a PR.
Dockerize a Rust API: Yes. An agent writes a multi-stage Dockerfile and compose file for your Rust API, solves the SQLx offline build, boots the stack in a sandbox and opens a PR.
Dockerize a Spring Boot App: Yes. An agent writes a multi-stage Dockerfile for your Spring Boot app, adds it to the compose file beside its database, boots it in a sandbox and opens a PR.
Dockerize a SvelteKit App: Yes. An agent switches your SvelteKit app to adapter-node, writes a multi-stage Dockerfile and compose file, boots the image in a sandbox and opens a pull request.
Dockerize a Symfony App: Yes. An agent writes a multi-stage Dockerfile for your Symfony app that compiles the asset map and warms the cache, boots the image to prove it, and opens a PR.
Dockerize a Vue App: Yes. An agent writes a two-stage Dockerfile for your Vite-built Vue app with an nginx config for the history router, builds and runs it, and opens a pull request.
Draft a Klaviyo Email Campaign From a Product Launch: Yes. An agent writes a short launch email, chooses an existing Klaviyo list or segment, and creates the campaign as an unsent draft.
Draft Outreach to an Open Source Project's Adopters: Yes. An agent reads the adopters file, researches each organization's public use of the project, and saves a sourced draft per row in your Notion CRM for approval.
Draft Outreach to Open Source Contributors: Yes. An agent ranks a project's contributors from 90 days of merged pull requests and saves a note citing their own work in your Notion CRM for you to send.
Draft Sales Outreach From a Notion CRM: Yes. For each new prospect row in Notion, an agent researches the company, fills your Research and Draft columns with sources, and asks you in Slack to approve.
Draft a Product Update Email in Resend From a Changelog: Yes. An agent turns a changelog into a Resend broadcast draft for the Customers segment and returns the draft id without sending.
Check Email Deliverability in Resend: Yes. An agent reads 14 days of Resend sends and the domain's status, then writes deliverability.md with bounce causes and any DNS fix.
Summarize PostHog Experiment Results: Yes. An agent reads an experiment's variants and goal metrics through PostHog and returns results.md with the winner, effect size, significance and caveats.
Write Release Notes for a TypeScript Library: Yes. An agent reads merged PRs between your last two tags and writes release-notes.md plus a migration guide with before/after samples checked against the source.
Report Failed Payments in Stripe: Yes. An agent lists the open Stripe invoices with failed payment attempts and writes a worklist ranked by amount, with each decline code and next retry date.
Find Dead Code in an Angular App: Yes. An agent lists the unused files, exports, components and dependencies in your Angular app, proving each by deleting it and running the build and Vitest.
Find Dead Code in a Flask App: Yes. An agent runs vulture and your linters on a Flask app, checks each candidate against templates, plugin hooks and CLI commands, and writes a report.
Find Dead Code in a Go Project: Yes. An agent runs whole-program reachability analysis on your Go module, removes each unreachable function on a scratch branch to prove it, and writes a report.
Find Dead Code in a Next.js Project: Yes. An agent finds unused files, exports and dependencies in your Next.js codebase and lists only what still type-checks and builds once removed.
Find Dead Code in a React Project: Yes. An agent lists the unused files, exports and dependencies in your React codebase, checking each one against the build and tests.
Find Dead Code in a Rust Workspace: Yes. An agent builds your Rust workspace with and without its features, traces every public item to its callers, and reports what can go, with semver impact.
Find Dead Code in a Vue Project: Yes. An agent runs knip over your Vue app, checks each unused file, export and dependency against the type check, build and tests, and reports what is safe to drop.
Fix Cloudflare Worker Errors From Its Logs: Yes. Give an agent the Worker's error, and it checks the bindings, reproduces the request with wrangler dev, and opens a PR with the fix and a Vitest test.
Fix Errors in a Hono Deployment: Yes. Give an agent your Hono Worker's logged error; it checks deployed bindings against wrangler.toml, reproduces the request locally and opens a pull request.
Fix an ASP.NET Core App Bug From a Datadog Monitor Alert: Yes. When a Datadog monitor fires, an agent reads its logs and traces, finds the failing ASP.NET Core code, fixes it with an xUnit test and opens a PR.
Fix a Django App Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run, the agent reads the logs and traces behind it, fixes the Django code with a TestCase and opens a pull request quoting the logs.
Fix an Express API Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent reads the error logs and traces, fixes the Express route with a Jest test and opens a pull request that quotes them.
Fix a FastAPI App Bug From a Datadog Monitor Alert: Yes. An agent reads the Datadog monitor, logs and traces behind an alert, finds the FastAPI route at fault, fixes it with a pytest test and opens a PR.
Fix a Go Service Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent follows its logs and traces into your Go code, adds a regression test, runs go test and opens a pull request.
Fix a Laravel App Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent reads its logs and traces, fixes the Laravel code with a PHPUnit test, runs php artisan test and opens a pull request.
Fix a NestJS API Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent reads the logs and traces, fixes the NestJS module with a Jest test and opens a pull request quoting them.
Fix a Phoenix App Bug From a Datadog Monitor Alert: Yes. An agent reads the logs and traces behind a Datadog alert, finds the failing Phoenix controller, fixes it with an ExUnit test and opens a PR.
Fix a Rails App Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent traces failing background jobs to your Rails code, adds a Minitest test, runs bin/rails test and opens a pull request.
Fix a Spring Boot App Bug From a Datadog Monitor Alert: Yes. A Datadog monitor starts a run; the agent reads its logs and traces, fixes the Spring Boot controller with a JUnit test and opens a pull request.
Fix a Broken Docker Build: Yes. An agent reads the failed CI log, reproduces the Docker build in its sandbox, fixes it, then builds and starts the image and opens a pull request.
Fix Failing GitHub Actions Checks in an ASP.NET Core App: Yes. When your .NET build goes red, an agent reads the failed job's log, reruns the same dotnet test or format command, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in a Django App: Yes. When your Django CI goes red, an agent reads the failed job's log, reproduces it with manage.py test, fixes the cause and opens a pull request.
Fix a Failing CI Build in a .NET Project: Yes. When a .NET solution's Actions run fails, an agent reads the log, reruns the pinned SDK's build and dotnet test, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in an Express API: Yes. When CI fails on your Express API, an agent reads the failed log, reruns your Jest suite against a real MongoDB, fixes the cause and opens a PR.
Fix Failing GitHub Actions Checks in a FastAPI App: Yes. When your FastAPI build fails, an agent reads the failed log, reruns pytest against Postgres with your migrations, fixes the cause and opens a PR.
Fix a Failing CI Build in a Fastify API: Yes. A failed workflow starts an agent that reads the log, reruns the build, lint and node:test steps against MySQL in a sandbox and opens a pull request.
Fix Failing GitHub Actions Checks in a Flask App: Yes. When CI fails on your Flask app, an agent reads the failed step's log, reruns your unittest suite, fixes the code that broke and opens a pull request.
Fix a Failing CI Build in a Gin Project: Yes. When a Gin project's Actions run fails, an agent reads the failed job's log, reruns the same script in its sandbox, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in a Go Service: Yes. When your Go build goes red, an agent reads the failed job's log, reruns go test with the same flags, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in a Laravel App: Yes. When a Laravel build fails, an agent reads the failed job's log, reruns php artisan test on the same PHP and database, fixes the cause and opens a PR.
Fix Failing GitHub Actions Checks in a NestJS API: Yes. When a NestJS workflow fails, an agent reads the failed job's log, reproduces it with npm test, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in a Next.js App: Yes. When your Next.js build goes red, an agent reads the failed job's log, reruns the same pnpm command, fixes the type or format error and opens a pull request.
Fix Failing GitHub Actions Checks in a Phoenix App: Yes. When your Phoenix build goes red, an agent reads the failed job's log, reruns the same mix command against Postgres, fixes the cause and opens a pull request.
Fix a Failing CI Build in a Python Project: Yes. A failed workflow run starts an agent that reads the log, reruns the same pytest command in a sandbox and opens a pull request that turns it green.
Fix Failing GitHub Actions Checks in a Rails App: Yes. When your Rails build goes red, an agent reads the failed job's log, reruns the same RSpec, lint or Brakeman command, fixes the cause and opens a pull request.
Fix a Failing CI Build in a Rust Project: Yes. A failed workflow starts an agent that reads the log, reruns the same cargo command in a sandbox and opens a pull request that makes it pass.
Fix a Failing CI Build in a Spring Boot Project: Yes. A failed workflow starts an agent that reads the log, reruns ./mvnw verify on the same JDK in a sandbox and opens a pull request with the fix.
Fix Failing GitHub Actions Checks in a SvelteKit App: Yes. An agent reads the failed step's log, reruns that step in a SvelteKit workspace, fixes the type, lint or Vitest error and opens a pull request.
Fix Failing GitHub Actions Checks in a Symfony App: Yes. When a PHPUnit job goes red, an agent reruns the failing matrix entry on the same PHP and database in its sandbox, fixes the cause and opens a pull request.
Fix Failing GitHub Actions Checks in a Terraform Module: Yes. An agent reads the failed pre-commit job, reruns terraform validate and the hook that broke on that Terraform version, and opens a fix PR.
Fix a Failing CI Build in a TypeScript Project: Yes. A failed workflow starts an agent that reads the log, reruns the same build and Vitest command in a sandbox and opens a pull request with the fix.
Fix a Failing CI Build in a Vue App: Yes. A failed workflow starts an agent that reads the log, reruns the failing lint, typecheck, Vitest, build or Cypress job in a sandbox and opens a pull request.
Fix Flaky Tests in an Elixir App: Yes. An agent loops the flaky ExUnit test until it fails, finds the cause (shared state, time, a race), fixes it and proves it with 50 clean runs, no retries.
Fix Flaky Tests in a Laravel App: An agent reruns your flaky Laravel test until it fails, finds the cause in ordering, time or shared data, fixes it, and proves it with 50 clean runs.
Fix Flaky Tests in a Rails App: An agent loops your flaky RSpec example until it fails, finds the order, clock or shared-record cause, fixes it, and shows 50 passing runs in a PR.
Fix Flaky Tests in a React App: An agent runs your flaky React or Cypress test with retries off until it fails, fixes the race or shared data behind it, and proves it with 20 clean runs.
Fix Flaky Tests in a Vue App: An agent runs your flaky Vitest or Playwright test with retries off until it fails, fixes the race or stale mock behind it, and proves the fix with 20 clean runs.
Fix a Django App From a Grafana Alert: Yes. The alert starts a run that queries its metric and Loki logs through Grafana, finds the failing view and opens a pull request with a TestCase.
Fix a FastAPI App From a Grafana Alert: Yes. The alert starts a run that reruns its Loki and Prometheus queries, follows the access log to the failing FastAPI route and opens a pull request with a test.
Fix a Go Service From a Grafana Alert: Yes. The alert starts a run that queries its Prometheus metric and Loki logs, finds the failing handler and opens a pull request with a Go test.
Fix the Cause of a Grafana Alert in Kubernetes: Yes. The alert starts a run that queries Prometheus and Loki through Grafana, finds the failing service in the cluster and opens a pull request with the fix.
Fix a NestJS API From a Grafana Alert: Yes. The alert starts a run that queries its metric and Loki logs through Grafana, traces the error to a module and opens a pull request with a Jest test.
Fix a Phoenix App From a Grafana Alert: Yes. The alert starts a run that reruns its PromEx and Loki queries, finds the failing action in your Phoenix stats API and opens a pull request with an ExUnit test.
Fix a Rails App From a Grafana Alert: Yes. The alert starts a run that reruns its Loki and Prometheus queries, follows the JSON request logs to the Rails controller at fault and opens a pull request.
Fix a Rust Service From a Grafana Alert: Yes. The alert starts a run that queries Prometheus and Loki through Grafana, finds the failing Axum handler and opens a pull request with a cargo test.
Fix a Spring Boot App From a Grafana Alert: Yes. When a Grafana alert fires, an agent queries its Prometheus and Loki data, finds the failing controller and opens a pull request with a fix and a JUnit test.
Fix Jira Bug Tickets With Pull Requests in an ASP.NET Core App: Yes. An agent reads the Jira bug, reproduces it with a test in your ASP.NET Core services, fixes it, opens a pull request and links it on the ticket.
Fix Jira Bug Tickets With Pull Requests in a Django App: Yes. An agent reads the Jira bug, reproduces it with a Django TestCase, fixes the view or integration, opens a pull request and comments the link on the ticket.
Fix Jira Bug Tickets With Pull Requests in a Laravel App: Yes. An agent reads the Jira bug, reproduces it with a PHPUnit test in your Laravel app, fixes it, opens a pull request and comments the link on the ticket.
Fix Jira Bug Tickets With Pull Requests in a Next.js App: Yes. An agent reads the Jira bug through the Atlassian connection, reproduces it in your Next.js team or billing code, opens a pull request and comments the link.
Fix Jira Bug Tickets With Pull Requests in a Rails App: Yes. An agent reads the Jira bug, reproduces it with a Minitest test in your Rails app, fixes the job or model, opens a pull request and links it on the ticket.
Fix Jira Bug Tickets With Pull Requests in a Spring Boot App: Yes. An agent reads the Jira bug, finds the Spring Boot service at fault, reproduces it with a JUnit test, fixes it and links the pull request on the ticket.
Fix Mobile Layout Bugs in a Laravel App: Yes. An agent opens a Laravel site at phone widths, fixes scroll and tap-target bugs, and takes a designer's corrections before the pull request.
Fix Mobile Layout Bugs in a Nuxt App: Yes. An agent opens a Nuxt app at 375 and 414 pixels, fixes layout breaks with the existing styles, and applies notes from a watching designer.
Fix N+1 Queries in a Django App: Yes. An agent counts each main page's queries with debug-toolbar, fixes N+1s with select_related or prefetch_related, and adds assertNumQueries tests.
Fix N+1 Queries in a Flask App: Yes. An agent counts the SQL each Flask page runs, finds the loops that query once per row, fixes them with eager loads and opens a PR with a query-count test.
Fix N+1 Queries in a Laravel App: Yes. An agent turns on Laravel's preventLazyLoading, finds each lazy load on your main pages, fixes it with eager loading and adds a query-count test per page.
Fix N+1 Queries in a Phoenix App: Yes. An agent counts the Ecto queries behind a slow Phoenix route, fixes the N+1 with a preload or a lateral join, and pins the count in a test before opening a PR.
Fix N+1 Queries in a Rails App: Yes. An agent runs your Rails pages with the Bullet gem, fixes each N+1 it reports with includes or preload, and adds a spec per page that counts queries.
Fix N+1 Queries in a Symfony App: Yes. From a slow-page alert, an agent counts the Doctrine queries behind the route, fixes the lazy loads with a join and opens a pull request with a query test.
Fix Angular Exceptions From PostHog Error Tracking: Yes. An agent takes the most frequent exception in PostHog error tracking, maps its stack to your Angular services, fixes it with a test and opens a pull request.
Fix Django Exceptions From PostHog Error Tracking: Yes. An agent reads your top PostHog error-tracking issue, maps its stack to your Django code, reproduces it in pytest and opens a pull request.
Fix Next.js Exceptions From PostHog Error Tracking: Yes. An agent takes your most frequent PostHog exception, maps its frames to the team or billing code in your Next.js app, reproduces it and opens a pull request.
Fix Nuxt Exceptions From PostHog Error Tracking: Yes. An agent takes your top PostHog exception, traces it to the Nuxt server route or component behind it, fixes it with a Vitest test and opens a pull request.
Fix React Exceptions From PostHog Error Tracking: Yes. An agent takes your most frequent PostHog exception, maps it to the React feature that throws, reproduces it in Vitest, fixes it and opens a pull request.
Fix SvelteKit Exceptions From PostHog Error Tracking: Yes. An agent takes your top PostHog exception, traces it to the SvelteKit load or action that throws, adds a Vitest test, fixes it and opens a pull request.
Fix Vue Exceptions From PostHog Error Tracking: Yes. An agent reads your top PostHog exception, finds the Vue code that throws it, reproduces it in a test and opens a pull request with the fix.
Fix Actix Web Errors from Sentry Alerts: Yes. An agent reads the Sentry event, reproduces the Actix Web error with an init_service test, fixes the handler and opens a PR with test and clippy output.
Turn Sentry Errors Into Fix Pull Requests for an Angular App: Yes. A Sentry alert starts a run that follows the frames into your Angular services, reproduces the error in a Vitest spec and opens a pull request with the fix.
Fix Ansible Errors from Sentry Alerts: Yes. An agent reads the Sentry event from the service that runs your Ansible role, reproduces the failing task with Molecule, fixes it and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for an ASP.NET Core App: Yes. A Sentry alert starts a run; the agent follows the .NET frames into your controllers, reproduces the exception with an xUnit test and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for an Astro Site: Yes. From a Sentry alert the agent finds the Astro page, endpoint or script that threw, reproduces it with a Vitest test, fixes it and opens a pull request.
Fix AWS CDK Errors from Sentry Alerts: Yes. An agent reads the Sentry event from a Lambda your CDK app deploys, reproduces it with Jest, fixes the handler or the stack, runs cdk synth and opens a PR.
Turn Sentry Errors Into Fix Pull Requests for a Cloudflare Worker: Yes. From a Sentry alert the agent finds the Worker handler that threw, reproduces it in workerd with a Vitest test on the bindings, fixes it and opens a PR.
Fix Sentry Errors in a Django App: Send the Sentry issue to an agent: it reads the Django stack trace, reproduces the error with a failing TestCase, fixes the view or model and opens a pull request.
Fix Sentry Errors in an Express App: Yes. A Sentry alert starts a run; the agent reads the stack trace, reproduces the error with a Jest test against the Express service and opens a pull request.
Fix Sentry Errors in a FastAPI App: Send the Sentry issue to an agent: it reads the FastAPI stack trace, reproduces the error with a failing pytest case, fixes the route and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a Flask App: Yes. A Sentry alert starts a run; the agent reads the issue's stack trace, reproduces it with a pytest test against the Flask app and opens a pull request.
Fix Flutter Errors from Sentry Alerts: Yes. An agent reads the Sentry event from your Flutter app, reproduces it with a widget test, fixes the cause, runs analyze and flutter test, and opens a PR.
Turn Sentry Errors Into Fix Pull Requests for a Go Service: Yes. A Sentry alert starts a run; the agent follows the goroutine frames into your Go packages, adds a failing test, fixes it and opens a pull request.
Fix Go CLI Errors from Sentry Alerts: Yes. An agent reads the Sentry event from your Go CLI, reproduces the panic or wrong output in a Go test, fixes it and opens a pull request.
Fix Helm Errors from Sentry Alerts: Yes. When a Sentry event names a value your Helm chart renders, an agent reproduces it with a helm-unittest case, fixes the template, bumps the chart and opens a PR.
Turn Sentry Errors Into Fix Pull Requests for a Hono App: Yes. An agent reads the Sentry issue, reproduces the failing Hono route in a Workers Vitest test, fixes the handler and opens a pull request that links the issue.
Fix Sentry Errors in a Laravel App: Yes. A Sentry alert starts a run; the agent reads the exception's frames, reproduces it with a Pest test in the Laravel app and opens a pull request with the fix.
Turn Sentry Errors Into Fix Pull Requests for a NestJS API: Yes. From a Sentry alert the agent reads the trace, reproduces the failing controller or service call with a Jest test in your NestJS API, fixes it and opens a PR.
Fix Sentry Errors in a Next.js App: Send the Sentry issue to an agent: it reads the stack trace, reproduces the error in your Next.js app with a failing test, fixes the cause and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a Nuxt App: Yes. A Sentry alert starts the run; the agent maps the frames to your Nuxt pages and composables, reproduces the error with Vitest and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a Phoenix App: Yes. A Sentry alert starts a run; the agent reads the Elixir stack trace, reproduces it with an ExUnit test against your Phoenix app and opens a pull request.
Fix Sentry Errors in a Rails App: Send the Sentry issue to an agent: it reads the Rails stack trace, reproduces the error in a Minitest case, fixes the controller or job and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a React App: Yes. A Sentry alert starts a run; the agent maps the browser frames to your React code, reproduces the error with a Vitest test and opens a pull request.
Fix Rocket Errors from Sentry Alerts: Yes. An agent reads the Sentry event, finds the Rocket handler or guard it names, reproduces the error with a test, fixes it and opens a PR with the results.
Turn Sentry Errors Into Fix Pull Requests for a Rust Service: Yes. A Sentry alert starts a run; the agent follows the frames into your Rust crates, reproduces the error with a cargo test and opens a pull request with the fix.
Fix Rust CLI Errors from Sentry Alerts: Yes. An agent reads the Sentry event from your Rust CLI, reproduces the wrong command or shell behavior with a test, fixes the cause and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a Spring Boot App: Yes. A Sentry alert starts a run; the agent reads the exception, reproduces it with a JUnit test against your Spring Boot controllers and opens a pull request.
Turn Sentry Errors Into Fix Pull Requests for a SvelteKit App: Yes. From a Sentry alert the agent reads the stack trace, reproduces the failing load or action with a Vitest test in your SvelteKit app and opens a pull request.
Fix Symfony Errors from Sentry Alerts: Yes. An agent reads the Sentry event from your Symfony app, reproduces it with a failing WebTestCase, fixes the cause, runs PHPUnit and PHPStan, and opens a PR.
Turn Sentry Errors Into Fix Pull Requests for a VS Code Extension: Yes. From a Sentry alert the agent maps the frames to your extension's source, reproduces the error with a VS Code test under xvfb, fixes it and opens a PR.
Turn Sentry Errors Into Fix Pull Requests for a Vue App: Yes. A Sentry alert starts a run; the agent follows the frames into your Vue stores and views, reproduces the error with a Vitest test and opens a pull request.
Fix Wagtail Errors from Sentry Alerts: Yes. An agent reads the Sentry issue, reproduces the failing Wagtail page in a Django test, fixes the model, view or template, and opens a pull request.
Fix a Django App Bug Reported in Slack: Yes. A Slack message can start an agent that reproduces a Django bug, adds a TestCase, and opens a pull request the team can steer.
Fix a Next.js App Bug Reported in Slack: Your Slack workflow sends a Next.js bug report to Rush, where an agent reproduces the cart failure and returns a tested fix for the team to review.
Fix a Rails App Bug Reported in Slack: Yes. A Slack report can start an agent that reproduces a Rails error in the issue-assignment flow, adds a Minitest, and opens a pull request.
Fix TypeScript Errors After an Upgrade: Yes. An agent bumps TypeScript in your NestJS project, runs tsc, fixes every error with real types instead of casts, and shows the count before and after.
Fix a Failed Vercel Deployment of an Astro Site: Yes. The failed deployment starts a run that reads the Vercel build log, reruns astro build in a sandbox and opens a pull request with the fix.
Fix a Failed Vercel Deployment of a Next.js App: Yes. A failed deployment starts a run; the agent reads the Vercel build log, reproduces next build in its sandbox and opens a pull request that fixes it.
Fix a Failed Vercel Deployment of a Nuxt App: Yes. A failed deployment starts a run; the agent reads the Vercel build log, reproduces nuxt build in its sandbox and opens a pull request with the fix.
Fix a Failed Vercel Deployment of a React App: Yes. A failed deployment starts a run; the agent reads the Vercel log, reproduces the Vite build of your React app and opens a pull request that fixes it.
Fix a Failed Vercel Deployment of a SvelteKit App: Yes. A failed deployment starts a run; the agent reads the Vercel log, reproduces vite build with adapter-vercel and opens a pull request with the fix.
Fix Vulnerable Dependencies in a NestJS App: Yes. An agent clears the npm audit advisories in your NestJS app with the smallest safe upgrades and opens a PR that still passes tests.
Fix Vulnerable Dependencies in a Node.js App: Yes. An agent clears the npm audit advisories in your Node.js app with the smallest safe upgrades and opens a PR that still passes tests.
Fix Vulnerable Dependencies in a React App: Yes. An agent audits your React app's lockfile, applies the smallest upgrade that clears each advisory, reruns the tests and opens a pull request with both audits.
Fix Vulnerable Dependencies in a Rust Project: Yes. An agent runs cargo audit on your Rust workspace, applies the smallest lockfile change per advisory, reruns the CI matrix and opens a pull request.
Audit Klaviyo Flows: Yes. An agent reads every Klaviyo flow and its step metrics, then writes flow-audit.md on gaps, weak steps and missing flows.
Find Where Users Drop Off in a PostHog Funnel: Yes. An agent runs your signup funnel in PostHog, finds the step that loses the most users and breaks it down by browser, device and referrer in funnel.md.
Generate a Typed API Client for a FastAPI Service: Yes. Your backend sends one request per customer; an agent runs their FastAPI service, generates a TypeScript client from its OpenAPI and returns the files.
Generate a Typed API Client for a NestJS Service: Yes. An agent starts the customer's NestJS service, reads its Swagger document, generates a typed Python client and tests it against the live server.
Generate a Typed API Client for a Spring Boot Service: Yes. An agent boots the customer's Spring Boot service, exports its OpenAPI with springdoc, generates a TypeScript client and runs it against the server.
Turn Labeled GitHub Issues Into Pull Requests for a Django App: Yes. Label a GitHub issue on a Django project and an agent reproduces it with a pytest test, fixes the code, runs the suite and opens a pull request that closes it.
Turn Labeled GitHub Issues Into Pull Requests for an Express API: Label a triaged Express issue and send it to Rush for a focused article-route fix, a regression test and a pull request linked to the report.
Turn Labeled GitHub Issues Into Pull Requests for a FastAPI App: Send a labeled FastAPI issue to Rush for a users-or-items route fix, database-backed pytest coverage and a pull request that links the issue.
Turn GitHub Issues into Pull Requests for a Fastify API: Yes. Label a GitHub issue on a Fastify API and an agent reproduces it with a node:test case against MySQL, fixes the route and opens a pull request that closes it.
Turn GitHub Issues into Pull Requests for a Go Project: Yes. Label a GitHub issue on a Go project and an agent reads it, adds a test, runs go test, and opens a pull request that links the issue.
Turn Labeled GitHub Issues Into Pull Requests for a Laravel App: Yes. Label a GitHub issue on a Laravel app and an agent reproduces it with a PHPUnit test, fixes the code, runs the suite and opens a pull request that closes it.
Turn Labeled GitHub Issues Into Pull Requests for a Phoenix App: Yes. Label a GitHub issue on a Phoenix app and an agent reproduces it with an ExUnit test, fixes the code, runs mix test and opens a pull request that closes it.
Turn GitHub Issues into Pull Requests for a Python Project: Yes. Label a GitHub issue on a Python project and an agent reads it, adds a pytest, runs the suite, and opens a pull request that links the issue.
Turn Labeled GitHub Issues Into Pull Requests for a Rails App: Yes. Label a GitHub issue on a Rails app and an agent reproduces it with an RSpec request spec, fixes the code, runs rspec and opens a pull request that closes it.
Turn GitHub Issues into Pull Requests for a React Project: Yes. Label a GitHub issue on a React project and an agent reads it, adds a Vitest test, runs the suite, and opens a pull request that links the issue.
Turn a Labeled GitHub Issue Into a Pull Request on a React Router App: Yes. Label a GitHub issue on a React Router 7 app and an agent reproduces it with a Playwright test, fixes it and opens a pull request that closes the issue.
Turn GitHub Issues into Pull Requests for a Rust Project: Yes. Label a GitHub issue on a Rust project and an agent reads it, adds a test, runs cargo test, and opens a pull request that links the issue.
Turn Labeled GitHub Issues Into Pull Requests for a Rust CLI: Yes. Label an issue on your Rust CLI and an agent writes the test, makes the change with its man page and completions, runs cargo test and opens a PR.
Turn GitHub Issues into Pull Requests for a Spring Boot App: Yes. Label a GitHub issue on a Spring Boot app and an agent reproduces it with a MockMvc test, fixes the controller and opens a pull request that closes the issue.
Turn Labeled GitHub Issues Into Pull Requests for a SvelteKit App: Yes. Label an issue and an agent reproduces the bug in your SvelteKit routes with a Vitest test, fixes it and opens a pull request that closes the issue.
Turn GitHub Issues into Pull Requests for a Vue App: Yes. Label a GitHub issue on a Vue 3 app and an agent reproduces it with a Vitest or Cypress case, fixes the page or store and opens a pull request that closes it.
Find Square Items to Reorder: Yes. An agent compares Square inventory with 30 days of orders and writes reorder.md for items under 14 days of stock.
Investigate a Celery Task Backlog in a Django App: Yes. An agent reads your Django code, Celery config and recent commits, and writes incident.md: ranked suspects with file:line evidence and a check for each.
Investigate Database Connection Pool Exhaustion in a FastAPI App: Yes. An agent traces how your FastAPI app opens and holds database connections and writes incident.md with ranked, file:line-cited suspects.
Find Why Signups Dropped in a Next.js App: Send Rush a signup-drop question with a PostHog connection and a Next.js repository, and get a report joining the funnel data to the commits that touched it.
Investigate a Crash Spike in a React Native App: Yes. An agent reads your React Native code, native config and the release's commits, and writes incident.md ranking crash suspects with file:line evidence.
Investigate CrashLoopBackOff Pods in Kubernetes: Yes. An agent reads your manifests, service code and recent commits, then writes an incident report ranking each suspect with file and line evidence.
Investigate Event Loop Blocking in an Express API: Yes. An agent reads your Express code, middleware and recent commits, then reports each synchronous hot path with its file, line and a check to confirm it.
Investigate GenServer Timeouts in a Phoenix App: Yes. An agent reads your Phoenix code, config and recent commits and writes an incident report ranking each GenServer timeout suspect with file:line evidence.
Investigate a Goroutine Leak in a Go Service: Yes. An agent reads your Go service and its recent commits, finds the goroutines that can block forever, and reports each with its file, line and a pprof check.
Investigate Connection Pool Exhaustion in a Spring Boot App: Yes. An agent reads your Spring Boot code, datasource settings and recent commits, and reports what holds HikariCP connections, with file, line and a check.
Investigate an ASP.NET Core App Incident With Datadog: Yes. An agent reads the error window in Datadog, matches it to recent commits in your ASP.NET Core identity and vault code, and writes a sourced incident.md.
Investigate a Django App Incident With Datadog: Yes. An agent reads the incident window in Datadog, lines it up with recent commits to your Django apps and writes incident.md with a timeline and cited evidence.
Investigate a Go Service Incident With Datadog: Yes. An agent reads the incident window in Datadog, lines it up with recent commits to your Go handlers and writes incident.md with cited evidence.
Investigate a NestJS API Incident With Datadog: Yes. An agent reads the error spike in Datadog, traces it to recent commits in your NestJS auth and users modules, and writes a sourced incident.md.
Investigate a Rails App Incident With Datadog: Yes. An agent reads the incident window in Datadog, matches it against your Rails request logs, jobs and recent commits, and writes incident.md with cited evidence.
Investigate a Spring Boot App Incident With Datadog: Yes. An agent reads the incident in Datadog across your Spring Boot services, matches it to recent commits and writes incident.md with evidence.
Investigate an Express API Incident With Grafana: Yes. An agent queries Loki and Prometheus in Grafana for the incident window, ties it to recent Express route commits, and writes incident.md.
Investigate a FastAPI App Incident With Grafana: Yes. An agent reads the window in Grafana, maps failing paths to your FastAPI meal-plan and shopping-list routers and recent commits, and writes incident.md.
Investigate a Go Service Incident With Grafana: Yes. An agent reads your Go service's Prometheus metrics and logs in Grafana, matches the incident to recent commits and writes incident.md.
Investigate a Kubernetes Outage with Grafana and Loki: Yes. An agent queries your Grafana metrics and Loki logs for the outage window, finds the first service that failed and writes a timeline with every query.
Investigate a Phoenix App Incident With Grafana: Yes. An agent queries Prometheus and Loki in Grafana for the incident window, ties the spike to recent commits in your Phoenix stats API, and writes incident.md.
Investigate a Rust Service Incident With Grafana: Yes. An agent reads your Rust service's OpenTelemetry metrics and logs in Grafana, ties the incident to recent commits and writes incident.md.
Investigate Lambda Timeouts in a Serverless Service: Yes. An agent reads your Serverless Framework service and recent commits and writes an incident report ranking each Lambda timeout suspect with file:line evidence.
Investigate a Latency Regression in a Go Service: An agent compares your Datadog traces before and after the rise, finds the span that grew, maps it to the Go code, and writes a cited report.
Investigate a Latency Regression in a Spring Boot Service: An agent compares your Datadog traces across the regression window, finds the span that grew, maps it to the Spring Boot code behind it, and writes a cited report.
Find a Memory Leak in an Express Service: Yes. An agent runs your Express service under load in a cloud sandbox, compares heap snapshots and writes a report naming what grows and the code that holds it.
Investigate a Memory Leak in a NestJS API: An agent reads your NestJS code, config and recent commits, ranks the memory-leak suspects, and writes incident.md with file:line evidence and a check per suspect.
Investigate a Microservices Outage from OpenTelemetry Data: Yes. An agent queries the span metrics behind your Grafana dashboards for the outage window, names the first service to fail, and writes incident.md with proof.
Investigate Prometheus Running Out of Memory: Yes. An agent reads your kube-prometheus-stack chart, values and recent commits and writes a report ranking why Prometheus is OOM killed, with file:line evidence.
Investigate a Queue Backlog in a Laravel App: Yes. An agent reads your Laravel jobs, schedule, queue config and recent commits, and reports why the queue backs up, with file and line for each cause.
Investigate a Sentry Error Spike in a Django App: Yes. An agent reads the new Sentry issues in your latest release, diffs that release against the one before, and names the commit most likely behind the spike.
Investigate a FastAPI App Incident With Sentry: Send a FastAPI incident window and Sentry evidence to Rush for a sourced timeline and likely cause, without changing application code.
Investigate a Laravel App Incident With Sentry: Yes. An agent reads the incident window in Sentry, compares it with your recent Laravel commits and writes a cited incident report without changing code.
Investigate a Sentry Error Spike in a Next.js App: Yes. An agent reads the Sentry issues new in your latest Next.js release, diffs it against the one before, and names the change most likely behind the spike.
Investigate a Sentry Error Spike in a Rails App: Yes. An agent reads the Sentry issues new in your latest Rails release, diffs that release against the last one, and names the commit most likely to blame.
Investigate Slow API Routes in a Next.js App: Yes. An agent reads the route handler, its queries, the schema and recent commits of your Next.js app and writes incident.md with ranked suspects and checks.
Investigate Slow Page Loads in a Laravel App: Yes. An agent reads your Laravel controllers, permission queries and recent commits, then ranks the likely causes of the slowdown with file, line and a check.
Find Slow Database Queries in a Django App: Yes. An agent runs your Django app on seeded Postgres, logs every query over 50 ms and reports the ORM code behind each with EXPLAIN ANALYZE and a fix.
Find Slow Database Queries in an Elixir App: Yes. An agent runs your Elixir app on seeded Postgres, logs every query over 50 ms and reports the Ecto code behind each with EXPLAIN ANALYZE and a fix.
Find Slow Database Queries in a Laravel App: Yes. An agent seeds your Laravel app in a sandbox, logs every query over 50 ms, and reports each with its Eloquent source, EXPLAIN ANALYZE and a fix.
Find Slow Database Queries in a Rails App: Yes. An agent seeds your Rails app with realistic data, exercises its pages, logs queries over 50 ms, and writes a report with each slow query, its code and the fix.
Find Slow Postgres Queries in a Supabase App: Yes. An agent reads pg_stat_statements on your Supabase project, matches the slowest queries to the calling code, and writes slow-queries.md with a fix for each.
Investigate Slow Requests in a Rails App: Yes. An agent reads your Rails code, config and recent commits and writes incident.md: suspects ranked with file:line evidence and the check that confirms each.
Investigate Slow Vector Search in Supabase: Yes. An agent reads your Supabase vector-search code and project, ranks what is making pgvector queries slow with file and line evidence, and writes incident.md.
Investigate Failing Stripe Webhooks in a Next.js App: An agent lists your failed Stripe deliveries, replays each event against your Next.js webhook handler in a sandbox, finds why it fails, and writes a report.
Investigate Thread Pool Starvation in an ASP.NET Core App: Yes. An agent reads your ASP.NET Core code, configuration and recent commits and returns an incident report ranking each suspect with the check that confirms it.
Investigate a Latency Spike from Traces: Yes. An agent follows the slow span through your instrumented services' code and config and writes an incident report ranking each suspect with file:line evidence.
Find Why a Vercel Deploy Broke an Astro Site: Yes. An agent reads the broken and previous Vercel deployments through your Vercel connection, diffs their commits, and names the change that broke it in a report.
Find Why a Vercel Deploy Broke a Next.js Site: An agent compares the broken Vercel deployment with the previous good one, diffs the commits between them, and names the change that broke production, with evidence.
Investigate Errors in a Cloudflare Worker: Yes. An agent reads your Worker's code, wrangler config and recent commits and writes an incident report ranking each error suspect with file:line evidence.
Turn a Jira Issue into a Pull Request for an ASP.NET Core App: Yes. Send one request from your terminal; an agent reads the Jira issue, does the work in your ASP.NET Core repo with tests and opens a PR.
Turn a Jira Issue into a Pull Request for a Spring Boot App: Yes. One request starts an agent that reads the Jira issue, makes the change in your Spring Boot repo, runs ./mvnw verify and opens a PR.
Run a Keyword Gap Analysis With Semrush: Yes. An agent reads organic keywords for your domain and two competitors in Semrush and returns gap.csv and gap.md, ranked by volume and difficulty.
Run a Large Refactor on an Elixir Codebase: Yes. An agent moves repeated Ecto queries into query modules in small commits, runs mix test after each, and opens one PR listing every commit.
Run a Large Refactor on a Go Codebase: Hand Rush a Go refactor that touches many files, and get a pull request in small commits, each with the build and tests run after it.
Run a Large Refactor on a Rails Codebase: Hand Rush a Rails refactor that touches many files, and get a pull request in small commits, each with the test suite run after it.
Audit Open Source Licenses in a Django Project: Yes. An agent resolves your Django lockfile in a sandbox and writes licenses.csv plus licenses.md flagging GPL, AGPL, LGPL, SSPL or unknown licenses.
Audit Open Source Licenses in a Go Project: Yes. An agent resolves your Go module graph in a sandbox and writes licenses.csv plus licenses.md flagging GPL, AGPL, LGPL, SSPL or unknown licenses.
Audit Open Source Licenses in a Next.js Project: Yes. An agent resolves your Next.js lockfile in a sandbox and writes licenses.csv plus licenses.md flagging GPL, AGPL, LGPL, SSPL or unknown licenses.
Audit Open Source Licenses in a Rust Project: Yes. An agent resolves your Cargo.lock graph in a sandbox and writes licenses.csv plus licenses.md flagging GPL, AGPL, LGPL, SSPL or unknown licenses.
Audit Performance of an Astro Site with Lighthouse: Yes. An agent builds your Astro site in a sandbox, runs Lighthouse in the browser on key pages and returns lighthouse.md tying each fix to a file in the repo.
Audit Performance of a Next.js Site with Lighthouse: Yes. An agent builds your Next.js site for production, runs Lighthouse on its key pages and ranks the fixes, each tied to the file in your code that causes it.
Audit Performance of a Nuxt Site with Lighthouse: Yes. An agent builds your Nuxt site, serves the production output, runs Lighthouse on its main pages and lists the five fixes that matter, each with its file.
Turn Linear Issues Into Pull Requests for an ASP.NET Core App: Yes. Label a Linear issue and an agent implements it in your ASP.NET Core API, adds xUnit tests, runs dotnet test and opens a pull request that links the issue.
Turn Linear Issues Into Pull Requests for a Django App: Yes. Point a run at a Linear issue and your Django repository, and the agent implements it, runs manage.py test and opens a pull request that links the issue.
Turn Linear Issues Into Pull Requests for an Express API: Give Rush a scoped Linear ticket for your Express auth or user routes and get a focused pull request with Jest evidence and the issue link.
Turn Linear Issues into Pull Requests for a FastAPI App: Label the issue and an agent implements it in your FastAPI routes and SQLModel models, adds the Alembic migration and pytest tests, and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a Flask App: Yes. Give the run a Linear issue and your Flask repository: the agent changes the forum or user blueprint, runs pytest and opens a pull request linking the issue.
Turn Linear Issues Into Pull Requests for a Go Service: Send Rush a scoped Linear issue for a Go feed service and get a linked pull request with regression coverage and the actual go test output.
Turn Linear Issues Into Pull Requests for a Laravel App: Yes. Give the run a Linear issue and your Laravel repository: the agent changes the page or permission code, runs PHPUnit and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a NestJS API: Turn a scoped Linear article-module issue into a NestJS pull request on Rush, with TypeORM-aware regression coverage and Jest results.
Turn Linear Issues into Pull Requests for a Next.js App: Label the issue and an agent reads it, implements it in your Next.js app's server actions and pages, checks the build and opens a pull request that links the issue.
Turn Linear Issues Into Pull Requests for a Nuxt App: Yes. Give the run a Linear issue and your Nuxt repository: the agent changes the media page or composable, runs Vitest and opens a pull request linking the issue.
Turn Linear Issues Into Pull Requests for a Phoenix App: Yes. Point a run at a Linear issue and your Phoenix repository: the agent changes the stats API, runs mix test on Postgres and ClickHouse and opens a linked PR.
Turn Linear Issues Into Pull Requests for a Rails App: Yes. Give the run a Linear issue and your Rails repository: the agent changes the push or API controller, runs bin/rails test and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a React App: Yes. Label a Linear issue and an agent implements it in your React app's components, machines or Express routes, adds the test and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a Rust Service: Give Rush a Rust LDAP or GraphQL ticket and get a linked pull request with permission-aware tests and checks for the affected workspace crates.
Turn Linear Issues Into Pull Requests for a Spring Boot App: Send Rush a Spring Boot owner-or-visit ticket for a linked pull request with focused JUnit coverage and the actual Maven test results.
Turn Linear Issues Into Pull Requests for a SvelteKit App: Yes. Give the run a Linear issue and your SvelteKit repository: the agent changes the article or profile route, runs the build and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a Symfony App: Yes. Give the run a Linear issue and your Symfony repository: the agent changes the blog controller, runs PHPUnit and PHPStan and opens a linked pull request.
Turn Linear Issues Into Pull Requests for a Vue App: Yes. Label a Linear issue and an agent implements it in your Vue 3 app's pages, store or locales, adds a test, runs the CI checks and opens a linked pull request.
Turn Notion Meeting Notes Into Action Items: Yes. An agent reads this week's meeting notes through Notion, extracts action items with owners and due dates, and adds missing rows to your Tasks database.
Report Stale GitLab Merge Requests: Yes. An agent reads open merge requests across a GitLab group and reports which wait on review, fail their pipeline or have conflicts, oldest first.
Migrate Cypress Tests to Playwright in a Vue App: Yes. An agent ports your Vue app's Cypress specs to Playwright, runs both suites headless against the same server and opens a pull request that removes Cypress.
Migrate an Express Project to ESLint Flat Config: Send Rush your Express repository to migrate ESLint config, preserve rule coverage, and return a pull request with lint evidence.
Migrate Jest to Vitest in an Electron App: Yes. An agent moves an Electron app's Jest suite to Vitest on its electron-vite config, ports the mocks and docblocks, and opens a pull request with tests green.
Migrate an Expo Project from Jest to Vitest: Yes. An agent converts your Expo app's Jest config, mocks, timers and snapshots to Vitest, proves the same tests pass, and opens a PR with both counts.
Migrate an Express Project from Jest to Vitest: Send Rush an Express repository to move its tests from Jest to Vitest, keep the same tests passing, and get a pull request with before and after counts.
Migrate a GitHub Action from Jest to Vitest: Yes. An agent moves a TypeScript action's ESM tests from Jest to Vitest, keeps the coverage badge and the dist check working, and opens a pull request.
Migrate a NestJS Project from Jest to Vitest: Send Rush a NestJS repository to move its tests from Jest to Vitest, keep the same tests passing, and get a pull request with before and after counts.
Migrate a React Project from Jest to Vitest: Yes. An agent moves your React test suite from Jest to Vitest, keeps every test passing with the same count, removes Jest, and opens a PR with the before and after.
Move a Laravel App from Laravel Mix to Vite: Send Rush a Laravel repository to replace Laravel Mix with Vite, swap every mix() call for @vite, and get a pull request with pages proven loading.
Upgrade a Next.js App to Tailwind CSS v4: Yes. An agent moves your Next.js app from Tailwind 3 to 4 in a cloud sandbox and opens a pull request with before and after screenshots of each page.
Migrate a Flask Project to uv: Yes. An agent moves your Flask project from requirements.txt to a pyproject.toml and uv.lock, updates the Dockerfile and proves the tests pass with uv run.
Migrate a Laravel Front End from Vue 2 to Vue 3: Send Rush a Laravel repository to move its Vue 2 front end to Vue 3 and Vite component by component, and get a pull request with screenshots of the main screens.
Find Noisy Datadog Monitors: Yes. An agent reads 30 days of Datadog monitor history and ranks the ones that page you and then recover on their own.
Prepare Month-End Accruals From Ramp Bills: Yes. An agent reads Ramp bills and recurring vendors, then returns accruals.csv for last month with an amount, GL category and basis for each line.
Build a Monthly Revenue Report From Stripe: Yes. An agent reads last month's Stripe charges, refunds and subscriptions and returns a revenue report with MRR movement, top customers and a daily CSV.
Build a Monthly Sales Report From PayPal: Yes. An agent reads last month's PayPal transactions and returns sales.md and transactions.csv with sales, refunds, fees, net and the top items.
Build a Monthly Spend Report From Ramp: Yes. An agent reads last month's Ramp cards, reimbursements and bills and returns spend.md by department, category and vendor, with the biggest changes.
Write an On-Call Handoff From Grafana: Yes. An agent reads a day of Grafana alerts, incidents and silences and writes the handoff the next on-call engineer reads.
Create a Notion Onboarding Page for Every New Customer Through an API: Yes. Your app starts one session per new customer; the agent researches the company, fills a page from your Notion template and returns its link.
Flag Out-of-Policy Spend in Ramp: Yes. Given your expense policy, an agent checks last month's Ramp card spend against it and lists each likely violation with the rule quoted.
Find Overdue and Unowned Tasks in Asana: Yes. An agent reads every open Asana task and returns overdue.md: overdue tasks by owner, tasks with no assignee or due date, and blocked tasks.
Make a Database Schema Change in a Django App as a Team: Yes. An agent writes a Device soft-delete migration, waits for approval, then updates the model, queries and tests in one pull request.
Make a Database Schema Change in a Rails App as a Team: An agent proposes a Rails email-table migration and its SQL, waits for your team's follow-up approval, then updates application code and tests in a PR.
Pin and Upgrade Container Images in Docker Compose: Yes. Rush runs an agent that pins each Compose image to a tag and digest, brings every stack up with docker compose up --wait, and opens one pull request.
Find Flaky GitLab Pipeline Jobs: Yes. An agent reads 14 days of GitLab pipelines, finds jobs that failed then passed on retry at the same commit, and ranks them with a log line.
Plan a Linear Issue Against a Django Codebase: Yes. An agent reads the Linear issue and your Django models and views, changes no code, and writes a plan with files, TestCase tests, risks and questions.
Plan a Linear Issue Against a Go Codebase: Yes. An agent reads the Linear issue and your Go packages, changes no code, and writes a plan: the files to change, the tests to add, the risks and open questions.
Plan a Linear Issue Against a Next.js Codebase: Yes. An agent reads the Linear issue and your Next.js server actions, changes nothing, and posts a plan: files to change, tests to add, risks and open questions.
Plan a Linear Issue Against a Ruby on Rails Codebase: Yes. An agent reads the Linear issue and your Rails controllers and specs, changes nothing, and posts a plan: files to change, specs to add, risks and questions.
Plan a Linear Issue Against a Spring Boot Codebase: Yes. An agent reads the Linear issue and your Spring Boot controllers, changes no code, and writes a plan with the files, JUnit tests, risks and open questions.
QA a Next.js App in a Real Browser: An agent clicks through your Next.js storefront in a real browser and returns a QA report with step screenshots, reproduction details and coverage gaps.
QA a Nuxt App in a Real Browser: An agent boots Nuxt Movies in a cloud sandbox, walks browse, search, movie and trailer flows in a real browser, and returns qa-report.md with screenshots.
QA a React App in a Real Browser: An agent starts the Cypress Real World App in a sandbox, walks sign-up, bank account and payment flows in a real browser, and returns qa-report.md.
Reconcile Stripe Payouts Against Charges: Yes. An agent matches last month's Stripe payouts to their balance transactions and writes a reconciliation with the lines that do not tie out.
Redesign a Page in a Next.js App with Your Team: Yes. The agent redesigns the page in its own sandbox, saves a screenshot after each pass, waits for your team's follow-ups, and opens the pull request once approved.
Redesign a Page in a Nuxt App with Your Team: An agent redesigns the Nuxt UI dashboard settings page under team follow-ups, posts browser screenshots after each pass, and opens a PR only when you approve.
Check Release Health in Sentry After a Deploy: Yes. An agent compares your latest Sentry release with the one before it and writes whether crash-free rate and new issues got worse.
Write Release Notes in Confluence From Jira Issues: Yes. An agent reads every Jira issue in your latest released fix version and creates a Confluence page of release notes in plain language.
Reproduce a Bug from a Linear Issue in a Next.js App: Yes. An agent investigates the reported Next.js date-range bug, writes a reproduction test and proposes a fix with before-and-after evidence.
Reproduce a Bug from a Linear Issue in a Phoenix App: Yes. A Linear bug report becomes a failing LiveView test, then a fix, in a pull request that links the issue and shows both results.
Reproduce a Bug from a Linear Issue in a Rails App: Yes. An agent investigates the Rails search report, reproduces it against the real search path and returns a tested fix when the bug is confirmed.
Research Maintainers of Self-Hosted Tools for Partnerships: Yes. An agent works through one category of awesome-selfhosted, checks each project's activity and license, and drafts sourced partnership notes in Notion.
Resize a Canva Design for Every Social Platform: Yes. An agent opens your Canva design through your Canva connection, creates copies sized for each platform, and exports them as PNG artifacts.
Build a Retention Cohort Report From PostHog: Yes. An agent runs weekly PostHog retention for the last eight signup weeks and writes which cohorts stayed and what they did first.
Review Accessibility in Angular Pull Requests: An agent runs your Angular app, checks changed screens with axe and a keyboard, and returns accessibility findings tied to the pull request diff.
Review Accessibility in Next.js Pull Requests: Yes. An agent runs your Next.js storefront in a browser, runs axe and the keyboard on each changed page, and comments each new violation on the pull request diff.
Review Accessibility on Every Nuxt Pull Request: Yes. On each pull request, an agent builds your Nuxt app, runs the changed pages through a browser with axe, reads components for labels and focus, and comments.
Review Pull Requests for Accessibility in a React App: Yes. An agent runs your React app at the PR's branch, checks changed screens with axe and the keyboard, and posts a review with a reproduction for each regression.
Review Accessibility in SvelteKit Pull Requests: An agent starts your SvelteKit app and checks changed routes, enhanced forms and keyboard behavior, returning evidence for new accessibility failures.
Review Accessibility in Vue Pull Requests: An agent runs your Vue app and reviews changed components with axe and keyboard checks, returning PR comments with reproducible accessibility evidence.
Review AWS CDK Pull Requests: Yes. An agent checks out the CDK pull request, runs npm test and cdk synth, diffs the templates and reviews IAM grants, removal policies and replacements.
Review Helm Chart Pull Requests: Yes. An agent checks out the chart change, runs helm lint, ct lint and helm unittest, renders old and new templates and reviews what an upgrade would change.
Review Database Migrations in an ASP.NET Core Pull Request: Yes. An agent checks a pull request's SQL scripts and EF migrations against each other, runs them on fresh databases and posts a review citing each file.
Review Database Migrations in Django Pull Requests: An agent reviews Django migration SQL and exercises it on sandbox Postgres, returning PR findings about locks, data loss and rollback limits.
Review Database Migrations in Elixir Pull Requests: An agent reviews your Ecto migration diff against sandbox Postgres, identifying lock risks, destructive statements and safer rollout sequences.
Review Alembic Migrations in FastAPI Pull Requests: An agent reads the Alembic migrations a FastAPI pull request adds, applies them to a fresh sandbox Postgres with data, and reviews locks, data loss and downgrades.
Review Database Migrations in a Flask App: Yes. On each pull request that adds an Alembic revision, an agent runs the upgrade and downgrade in a sandbox, compares it to your models and comments.
Review Database Migrations in Next.js Pull Requests: Yes. An agent applies the pull request's Drizzle migration to a fresh Postgres and comments on any statement that locks a table, drops data or cannot be undone.
Review Database Migrations in Rails Pull Requests: Yes. An agent runs the pull request's Active Record migrations up and down on a fresh Postgres and comments on locks, table rewrites and data loss before merge.
Review Supabase Migrations in Every Pull Request: Yes. On every pull request an agent reads new Supabase migrations against your live schema and flags missing row-level security, broad grants and slow locks.
Review Argo CD App Changes in Pull Requests: An agent renders your Argo CD app changes, runs kubeconform and kube-linter, and reviews missing limits, probes and non-root settings before merge.
Review Kubernetes Manifests in Pull Requests: Yes. An agent renders your Helm and Kustomize output, runs kubeconform and kube-linter, and comments on containers without limits, probes or a non-root user.
Review Pull Requests on an Actix Web API: Yes. An agent checks out the pull request, runs cargo clippy with -D warnings and cargo test in its sandbox, and posts one review on extractors and shared state.
Review Pull Requests Automatically in an Angular App: Yes. An agent checks out the pull request, runs npm test (Vitest) in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests on an Ansible Role: Yes. An agent checks out the pull request to your Ansible role, runs yamllint, ansible-lint and Molecule, and posts one review on idempotence, become and precedence.
Review Pull Requests on an ASP.NET Core App: Yes. An agent checks out the pull request, runs dotnet build and dotnet test in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests Automatically in an Astro Site: Ask Rush to review an Astro pull request with the workspace's real pnpm and Vitest setup, then return file-and-line findings without commits.
Review Pull Requests on a Chrome Extension Project: Yes. An agent checks out the pull request, runs npm test and npm run build in its sandbox, reads the built manifest, and posts one review on permissions.
Review Pull Requests on a Cloudflare Workers Project: Yes. An agent checks out the pull request, runs the template linter, its tests and wrangler deploy --dry-run in its sandbox, and posts one review on bindings.
Review Pull Requests on a dbt Project: Yes. An agent checks out the pull request, runs dbt build on DuckDB in its sandbox, and posts one review on grain, join fan-out and missing tests.
Review Pull Requests on a Django App: Yes. An agent checks out the pull request, runs the Django test suite in its own sandbox, and posts inline comments on the lines where the change is wrong.
Review Pull Requests on an Electron App: Yes. An agent checks out the pull request, runs package, lint, tsc, jest and the Electron smoke test in its sandbox, and posts one review on IPC and preload.
Review Pull Requests Automatically in an Express API: Yes. An agent checks out the pull request, runs npm test (Jest) in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests on a FastAPI API: Yes. An agent checks out the pull request, runs uv run pytest and the lint script in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests Automatically in a Fastify API: Yes. An agent checks out the Fastify pull request, starts MySQL, runs the node:test suite and posts one review that cites file and line.
Review Pull Requests Automatically in a Flask App: Yes. An agent checks out the pull request, runs pytest in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests on a Flutter App: Yes. An agent checks out the pull request, runs flutter analyze and flutter test in its sandbox, and posts one review on rebuilds, async gaps and state.
Review Pull Requests on a Gatsby Site: Yes. An agent checks out the pull request, builds the Gatsby site in its own sandbox, checks the generated pages and feed, and posts one review citing file and line.
Review Pull Requests on a Gin API: Yes. An agent checks out the pull request, runs go vet and go test -race in its sandbox, and posts one review on errors, GORM queries and goroutines.
Review Pull Requests Automatically in a Go Service: Yes. An agent checks out the pull request, runs go test ./... in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests on a Go CLI Tool: Yes. An agent checks out the pull request, runs go vet, go test -race and golangci-lint in its sandbox, and posts one review on flags, output and errors.
Review Pull Requests on a Hono API: Yes. An agent checks out the pull request, runs the touched example's Vitest suite and tsc in its sandbox, and posts one review on middleware and validation.
Review Pull Requests on a Ktor Server: Yes. An agent checks out the pull request, runs ./gradlew check in each touched sample in its sandbox, and posts one review on plugin order and coroutines.
Review Pull Requests on a Laravel App: Yes. An agent checks out the pull request, runs the PHPUnit suite in its own sandbox, and posts inline comments on the lines where the change is wrong.
Review Pull Requests Automatically in a NestJS API: Yes. An agent checks out the NestJS pull request, runs npm test, and posts one review of the article module with file and line citations.
Review Pull Requests Automatically in a Next.js App: Yes. The agent checks out the pull request, runs pnpm prettier:check, tsc and next build in its own sandbox, and posts one review citing file and line.
Review Pull Requests Automatically in a Nuxt App: Yes. An agent checks out the Nuxt pull request, runs npx vitest run, and posts one review of the server routes with the command's real result.
Review Pull Requests Automatically in a Phoenix App: Have Rush review a Phoenix pull request with real Mix and database checks, then post precise findings without changing the branch.
Review Pull Requests on a Python Library: Yes. An agent checks out the pull request, runs the library's own check, test and coverage scripts in its sandbox, and posts one review that cites file and line.
Review Pull Requests on a Quarkus Service: Yes. An agent checks out the pull request, runs ./mvnw verify in each touched quickstart in its sandbox, and posts one review on CDI scopes and Panache queries.
Review Pull Requests Automatically in a Rails App: Yes. An agent checks out the Rails pull request, runs bin/rails test, and posts one review of the issue-assignment code with file and line citations.
Review Pull Requests Automatically in a React App: Yes. An agent checks out the React pull request, runs typecheck, lint, Vitest and the Cypress specs it touches in a sandbox browser, and posts one review.
Review Pull Requests on a React Native App: Yes. An agent checks out the React Native pull request, runs pnpm lint, type-check and test, and posts one review citing file and line.
Review Pull Requests on a React Router App: Yes. An agent checks out the pull request, runs pnpm typecheck, pnpm build and the template's Playwright test in its sandbox, and posts one review.
Review Pull Requests on a Rocket Server: Yes. An agent checks out the Rocket pull request, runs clippy and the tests with the repository's feature matrix, and posts one review citing file and line.
Review Pull Requests Automatically in a Rust Service: Yes. An agent checks out the Rust pull request, runs cargo test, and posts one review of the article handlers with file and line citations.
Review Pull Requests on a Rust CLI Tool: Yes. An agent checks out the pull request to your Rust CLI, runs clippy, rustfmt and cargo test in its own sandbox, and posts one review that cites file and line.
Review Pull Requests Automatically in a Spring Boot App: Yes. An agent checks out the Spring Boot pull request, runs ./mvnw test, and posts one review of the owner and visit controllers.
Review Pull Requests Automatically in a SvelteKit App: Yes. An agent checks out the SvelteKit pull request, runs npx vitest run, and posts one review of the article and profile routes with that output.
Review Pull Requests Automatically in a Symfony App: Yes. The agent checks out the pull request, runs the PHPUnit suites and PHPStan in its own sandbox, and posts one review citing file and line for each finding.
Review Pull Requests Automatically in a Vue App: Yes. An agent checks out the Vue pull request, runs npx vitest run, and posts one review of the article store and views with that command's result.
Review Pull Requests on a Wagtail Site: Yes. An agent checks out the pull request, runs manage.py check, the migration check, manage.py test and make lint in its sandbox, and posts one review.
Review Pulumi Pull Requests: Yes. An agent checks out each Pulumi pull request, works out which programs changed, runs the lint, build and unit checks CI runs, and posts a review with output.
Review Every Refund Request With Stripe From Your Backend: Yes. Your backend starts one run per refund request; the agent reads the customer's Stripe history and returns a JSON recommendation without refunding.
Review Terraform Pull Requests for a GKE Module: Yes. An agent runs terraform fmt, validate and plan on your GKE module's examples and comments on each resource the change would replace, destroy or expose.
Review Terraform Pull Requests for an AWS Module: Yes. An agent runs terraform validate and plan on your module's examples and comments with what the change would destroy or expose.
Review GitHub Actions Workflow Changes: Yes. An agent runs actionlint and your build on the pull request, then reviews workflow permissions, untrusted input in run steps and unpinned actions.
Audit Row-Level Security in a Supabase Project: Yes. An agent reads every public Supabase table, its policies and its grants, and writes where row-level security is missing or wide open.
Schedule a Week of Social Posts in Buffer: Yes. Given an article, an agent writes five posts per connected Buffer channel and saves them as drafts over the next 7 days for you to review.
Run a Security Audit on an Angular App: Yes. An agent runs OWASP Juice Shop in a sandbox, checks injection, access control, auth and data exposure, and writes the findings without changing code.
Run a Security Audit on an ASP.NET Core App: Yes. An agent reads your ASP.NET Core pipeline, identity setup, CORS, endpoints and configuration, scans the packages, and reports each finding with a fix.
Run a Security Audit on an Electron App: Yes. An agent reads your Electron main, preload and renderer code, checks window options, IPC, CSP, navigation and the updater, runs the app, and writes a report.
Run a Security Audit on an Elixir App: Yes. An agent compiles your Phoenix app in a sandbox, runs hex.audit, mix_audit and sobelow, reads the plugs and config, and writes a report that changes no code.
Run a Security Audit on a FastAPI App: Yes. An agent boots your FastAPI app with Postgres in its sandbox, checks auth, secrets, access control and dev-only routes, and reports without changing code.
Run a Security Audit on a Flask App: Yes. An agent reads your Flask app's auth, sessions, uploads and plugins, runs ruff's bandit rules and pip-audit, and reports each finding with file and line.
Run a Security Audit on a Go App: Yes. An agent builds and runs your Go service in its own sandbox, checks each finding against the running binary, and writes a report without touching code.
Run a Security Audit on a NestJS API: Yes. An agent boots your NestJS API in its own sandbox, confirms each finding with a real request against the running app, and writes a report without changing code.
Run a Security Audit on a Node.js App: Yes. An agent runs your Node.js app in its own sandbox, confirms each finding against the running app, and writes a report without changing your code.
Run a Security Audit on a PHP App: Yes. An agent runs DVWA in a sandbox, checks injection, access control, auth and data exposure, and writes the findings without changing code.
Run a Security Audit on a Spring Boot App: Yes. An agent builds and runs your Spring Boot app in its own sandbox, confirms each finding against it, and writes a report without touching your code.
Run a Security Audit on a SvelteKit App: Yes. An agent reads your SvelteKit app's hooks, form actions, cookies and HTML rendering, audits the dependencies, and reports each finding with a fix.
Run a Security Audit on a Symfony App: Yes. An agent runs your Symfony app in a sandbox, checks dependencies, firewalls, CSRF, authorization and escaping, and reports each finding with file and line.
Run a Security Audit on a Terraform Module: Yes. An agent validates your Terraform module and its examples, runs tflint, Trivy and Checkov, reads the security defaults, and writes a report. It changes no code.
Security Review Pull Requests on a Django App: Yes. An agent traces each new request parameter in the pull request to the database or shell, checks the new view's authorization and flags secrets in the diff.
Security Review Pull Requests on an Express App: Yes. An agent traces each new Express route's input to Prisma, the filesystem or a shell, checks auth and ownership like its neighbours, and flags leaked secrets.
Security Review Pull Requests on a Laravel App: Yes. An agent reviews each Laravel pull request for SQL injection, missing authorization and leaked secrets, and comments only where the diff is unsafe.
Security Review Pull Requests on a Rails App: Yes. An agent checks each Rails pull request for SQL injection, a route that skips its neighbours' auth, and secrets, and comments only on a real finding.
Run an SEO Audit on an Astro Site: Yes. An agent builds your Astro site in a sandbox, crawls the output for titles, canonicals, robots rules and structured data, and maps each issue to its file.
Run an SEO Audit on a Next.js Site: Yes. An agent pulls Ahrefs site-audit issues for a Next.js blog and maps each one to the file that renders the page.
Run an SEO Audit on a Starlight Site: Yes. An agent pulls Semrush site-audit issues for a Starlight docs site and maps each one to the template that emits the tag.
Build an SLO Report From Datadog: Yes. An agent reads your Datadog SLOs and returns slo.md with each target, the value achieved, the error budget left, the burn rate and what spent it.
Make Social Graphics From a Canva Brand Template: An agent fills a Canva brand template with your announcements and returns PNG exports and design links without changing the original template.
Report Social Post Performance From Buffer: An agent reads Buffer post metrics and returns a channel-by-channel report of strong posts, weak posts and patterns worth testing next month.
Write a Jira Sprint Report: Yes. An agent reads your last closed Jira sprint and writes sprint-report.md: what shipped, what slipped and why, scope added mid-sprint and points.
Find Stale Feature Flags in PostHog: Yes. An agent lists your PostHog feature flags and returns the ones safe to remove: fully rolled out, not evaluated in 30 days, or disabled.
Find Untested Code in an Angular App: Yes. An agent runs your Angular app's Vitest suite under coverage in its own sandbox and reports the riskiest untested interceptors, directives and pages.
Find Untested Code in a Flask App: Yes. An agent runs your Flask test suite under coverage in its own sandbox and reports the riskiest untested routes and model methods, without changing anything.
Find Test Coverage Gaps in a Gin Service: Yes. An agent runs your Gin service's tests under coverage in its sandbox and ranks the untested handlers, with the test that would cover each, changing nothing.
Find Untested Code in a NestJS App: Yes. An agent runs your NestJS test suite with coverage in its own sandbox and reports the riskiest untested code, without changing anything.
Find Untested Code in a Next.js App: Yes. An agent runs your Next.js test suite with coverage in its own sandbox and reports the riskiest untested code, without changing anything.
Find Untested Code in a Wagtail App: Yes. An agent runs your Wagtail tests with coverage in a sandbox and ranks the ten riskiest untested files, with the test that would cover each.
Add Missing Tests to Every Pull Request in an ASP.NET Core App: Yes. An agent reads each pull request, writes tests for the ordering and basket code it changes, runs dotnet test and pushes them to the same branch.
Add Missing Tests to Every Pull Request in a Django App: Yes. An agent reads each pull request, writes Django TestCase tests for what it adds to your apps, runs manage.py test and pushes them to the branch.
Add Missing Tests to Every Pull Request in an Express API: Yes. An agent reads each pull request to your Express API, writes Jest tests for the article routes it changes, runs npm test and pushes them back.
Add Missing Tests to Every Pull Request in a FastAPI App: Yes. An agent reads each pull request to your FastAPI app, writes pytest tests for the users and items routes it changes and pushes them back.
Add Missing Tests to Every Pull Request in a Flask App: Yes. An agent reads each pull request to your Flask app, writes pytest tests for the challenges API code it changes, runs pytest and pushes them.
Add Missing Tests to Every Pull Request in a Go Service: Yes. An agent reads each pull request to your Go service, writes tests for the users and articles packages it changes, runs go test ./... and pushes them.
Add Missing Tests to Every Pull Request in a Laravel App: Yes. An agent reads each pull request to your Laravel app, writes PHPUnit tests for the song and playlist code it changes, runs artisan test and pushes them.
Add Missing Tests to Every Pull Request in a NestJS API: Yes. An agent reads each pull request to your NestJS API, writes Jest tests for the auth and users modules it changes, runs npm test and pushes them back.
Add Missing Tests to Every Pull Request in a Next.js App: Yes. An agent reads each pull request to your Next.js app, writes Vitest tests for the posts editor and API routes it changes and pushes them back.
Add Missing Tests to Every Pull Request in a Nuxt App: Yes. An agent reads each pull request to your Nuxt app, writes Vitest tests for the server API routes it changes, runs vitest and pushes them.
Add Missing Tests to Every Pull Request in a Phoenix App: An agent reads each Phoenix pull request, adds ExUnit coverage for changed behavior, and returns test commits with the commands that verify them.
Add Missing Tests to Every Pull Request in a Rails App: Send a Rails pull request to an agent that fills gaps in its RSpec request coverage and returns test commits with reproducible check output.
Add Missing Tests to Every Pull Request in a React App: Yes. On each pull request an agent reads the React diff, writes the Vitest or Cypress tests it lacks, runs them in a sandbox browser and pushes them to the branch.
Add Missing Tests to Every Pull Request in a Rust Service: Yes. On each new pull request an agent reads the diff, writes cargo tests for the untested Rust code, runs cargo test and pushes them to the same branch.
Add Missing Tests to Every Pull Request in a Spring Boot App: Yes. For each new pull request an agent finds the untested Spring Boot code, writes JUnit tests, runs ./mvnw test and pushes them to the same branch.
Add Missing Tests to Every Pull Request in a SvelteKit App: Yes. When a pull request opens, an agent writes Vitest tests for the SvelteKit code it changes, runs them and pushes the passing tests to the same branch.
Add Missing Tests to Every Pull Request in a Symfony App: An agent reads a Symfony API pull request, adds PHPUnit tests for uncovered behavior, and returns test commits with the exact checks run.
Find Your Best Customers in Square: An agent reads Square customers and orders, ranks recent customer spend, and returns a read-only report of regulars who have stopped visiting.
Translate a Next.js App into Another Language: Yes. An agent moves your Next.js app's hard-coded strings into message files, adds Spanish and a locale switcher, and screenshots the pages in Spanish.
Translate a Nuxt App Into Another Language: Yes. An agent adds a locale to your Nuxt i18n app, translates every key in the source file, fixes the keys other locales are missing, and guards it all with a test.
Triage New Linear Issues Every Morning: Yes. Each morning an agent reads the issues in your Linear Triage queue and writes triage.md with a priority, labels, an owner and any duplicate.
List Unpaid PayPal Invoices and Draft Reminders: An agent reads overdue PayPal invoices and returns a collections table with customer-specific reminder drafts, without sending any messages.
Update Gin Dependencies Every Week: Yes. Each week an agent runs go get -u in groups, tests and lints after each, and opens one pull request listing every bump taken and each one left out with why.
Upgrade Pinned GitHub Actions to the Latest Releases: Yes. A Rush agent pins every uses: line to a release commit SHA, bumps your action's npm dependencies, runs npm run all and opens one pull request.
Update Pinned GitHub Actions in a Rust Repo: An agent moves every third-party GitHub Action in your Rust workflows to its current release pinned by commit SHA and opens a pull request when checks pass.
Update Pinned GitHub Actions in a Tauri Repo: Yes. A Rush agent moves every third-party action in your Tauri workflows to its latest release, pinned by commit SHA, and opens one pull request with checks.
Upgrade Angular to the Latest Version: An agent runs ng update on your Angular app, keeps only bumps that pass the repo’s test and build commands, and opens a pull request with one line per change.
Upgrade Ansible Collections and Fix Lint: Yes. A Rush agent pins the collections your role uses in requirements.yml, runs ansible-lint and molecule test, and opens a pull request with every bump.
Upgrade Astro and Its Integrations in an Astro Site: Yes. A Rush agent bumps Astro, its integrations and plugins with pnpm, runs astro check and the full build, and opens one pull request that leaves out what broke.
Upgrade aws-cdk-lib in a CDK App: Yes. A Rush agent bumps aws-cdk-lib and the CDK CLI, runs npm test and cdk synth, and explains every template change in one pull request.
Upgrade Axum and Cargo Dependencies: Yes. An agent upgrades an Axum API's Cargo dependencies in groups, ports the code across Axum and SQLx breaking releases, and opens one pull request.
Upgrade Cargo Dependencies in a Rust CLI: Yes. An agent upgrades a Rust CLI's Cargo dependencies in groups, runs the tests, clippy and the MSRV check after each, and opens one PR with the skips explained.
Upgrade Helm Chart Dependencies: Yes. A Rush agent bumps your chart's subchart versions, runs helm lint, ct lint and helm unittest, bumps the chart version and opens one pull request.
Upgrade Filament and Composer Dependencies: Yes. Each week an agent runs composer update in groups on a Filament panel, keeps what passes Pest and PHPStan, and opens one pull request.
Upgrade dbt and Its Packages: Yes. A Rush agent upgrades dbt, its adapter and packages.yml, runs dbt build on DuckDB in its sandbox, and opens a pull request per tested bump.
Upgrade ASP.NET Core Dependencies Every Week: Yes. Each week a Rush agent bumps your NuGet packages in Directory.Packages.props, runs dotnet test, drops what fails and opens one pull request.
Upgrade Django Dependencies Every Week: Yes. Each week a Rush agent bumps the pinned packages in requirements.txt, runs python manage.py test, drops what breaks and opens one pull request.
Upgrade Express Dependencies Every Week: Yes. Each week a Rush agent upgrades your Express app's npm packages, runs npm test and the build, reverts what breaks and opens one pull request.
Upgrade Flask Dependencies Every Week: Yes. Each week a Rush agent upgrades your Flask app's Python packages in the lockfile, runs pytest, reverts what breaks and opens one pull request.
Upgrade Go Dependencies Every Week: Yes. Each week a Rush agent bumps your Go modules, runs go test ./... with your build tags, reverts what breaks and opens one tested pull request.
Upgrade Laravel Dependencies Every Week: Yes. Each week a Rush agent bumps your Composer packages, runs php artisan test against a test database, reverts what breaks and opens one pull request.
Upgrade NestJS Dependencies Every Week: Yes. Each week a Rush agent bumps your NestJS app's exact-pinned npm packages, runs the build and e2e tests, reverts what fails and opens one pull request.
Upgrade Nuxt Dependencies Every Week: Yes. Each week a Rush agent upgrades your Nuxt app's packages, runs Vitest, lint and vue-tsc, reverts what breaks and opens one tested pull request.
Upgrade Ruby on Rails Dependencies Every Week: Yes. A weekly request has an agent run bundle update, test each gem bump with bin/rails test, drop the ones that fail, and open one pull request.
Upgrade Rust Dependencies Every Week: Yes. Each week an agent raises your Cargo versions, runs cargo test against them, reverts any crate that breaks the build, and opens one pull request.
Upgrade Spring Boot Dependencies Every Week: Yes. A weekly agent run moves your Spring Boot parent, BOMs and Maven properties forward, runs ./mvnw test, and opens one PR without the bumps that fail.
Upgrade SvelteKit Dependencies Every Week: Yes. Once a week an agent updates your SvelteKit app's npm packages, runs vitest run in each workspace, rolls back what fails, and opens one pull request.
Upgrade Symfony Dependencies Every Week: Yes. Each week an agent bumps your Composer packages inside the Symfony version Flex pins, runs phpunit and phpstan, reverts what breaks and opens one pull request.
Upgrade Electron and npm Dependencies in an Electron App: Yes. An agent upgrades Electron and your npm packages, runs npm test, npm run package and a startup smoke test, and opens a PR without the bumps that fail.
Upgrade the Expo SDK in a React Native App: An agent upgrades the Expo SDK with npx expo install --fix, keeps bumps that pass pnpm lint, type-check and test, and opens a pull request with one line per change.
Upgrade firebase-functions and firebase-admin: Yes. A Rush agent bumps firebase-functions and firebase-admin with pnpm, runs each sample's lint and tests, and opens one pull request with every bump.
Upgrade Laravel 11 to Laravel 13: An agent upgrades Laravel 11 to 13 using the official guide, runs Pest after each step, and opens a PR listing changes and open human decisions.
Upgrade Next.js 13 to Next.js 16: Yes. An agent takes a Next.js 13 app to 16 step by step from the upgrade guide, keeps the build and lint green at each step, and lists what needs a person to decide.
Upgrade Phoenix 1.7 to Phoenix 1.8: Send one request and an agent moves your app from Phoenix 1.7 to 1.8, works through the changelog's breaking changes, runs mix test, and opens a PR.
Upgrade React 18 to React 19: An agent upgrades React 18 to React 19 using the official guide, runs the repo's tests after each step, and opens a PR with changes and open decisions.
Upgrade Spring Boot 2.6 to Spring Boot 4: An agent upgrades Spring Boot 2.6 toward Boot 4 using the official guides, runs tests after each step, and opens a PR with changes and open decisions.
Upgrade Gatsby and Its Plugins: Yes. An agent upgrades Gatsby and every gatsby-* plugin together, runs npm run build, checks the built pages and feed, and opens one pull request.
Upgrade Go Modules in a Go CLI: Yes. Each week an agent runs go get -u in groups on a Go CLI, builds, vets, race-tests and runs govulncheck after each, and opens one pull request.
Upgrade Ktor and Gradle Dependencies: Yes. Each week an agent bumps the Ktor plugin, Kotlin and libraries in a Ktor sample's Gradle build, tests after each group, and opens one pull request.
Upgrade Hex Dependencies in a Phoenix App: Yes. An agent upgrades a Phoenix app's Hex packages in groups, keeps the pins your mix.exs explains, runs mix test against Postgres after each and opens one PR.
Plan an Upgrade to Next.js 16: Yes. An agent reads your Next.js app and reports each change Next.js 16 needs, with the file, the line and how much work it is.
Upgrade a Quarkus App to Java 25: Yes. An agent moves your Quarkus build, Dockerfiles and CI to Java 25, runs the tests on JDK 25, fixes what breaks and opens a pull request.
Upgrade a Spring Boot App to Java 25: Yes. An agent moves your Spring Boot build to Java 25, fixes what the new JDK breaks and opens a pull request with passing tests.
Upgrade the Lambda Runtime in a Serverless Service: Yes. A Rush agent moves provider.runtime to a current Node.js Lambda runtime, bumps npm dependencies, runs serverless package and opens a pull request.
Upgrade an Express App to Node 24: Ask Rush to move your Express app to Node 24, inspect its runtime settings, and return a pull request with build, test and container evidence.
Upgrade a NestJS App to Node 24: Yes. An agent installs and tests your NestJS app on Node 24 in a sandbox, fixes what breaks, pins the version everywhere and opens one pull request.
Upgrade npm Dependencies in a Chrome Extension Project: Yes. Each week an agent updates your Chrome extension's npm packages, runs Jest and the webpack production build, drops what breaks and opens one pull request.
Upgrade npm Dependencies in a Fastify API: Yes. Each week an agent raises your Fastify API's package ranges, runs lint, build and the node:test suite against MySQL, drops what breaks and opens one PR.
Upgrade npm Dependencies in a Hono API: Yes. Each week an agent updates the packages in each of your Hono apps with npm, runs every app's test or build script, drops what breaks and opens one PR.
Upgrade npm Dependencies in a Next.js App: Yes. Each week an agent upgrades a Next.js app's npm dependencies in groups with pnpm, keeps what builds and type-checks, and opens one pull request with each bump.
Upgrade npm Dependencies in a React Router App: Yes. Each week an agent updates your React Router app's packages with pnpm, runs typecheck, build and Playwright, drops what breaks and opens one pull request.
Upgrade npm Dependencies in a Vite React App: Yes. Each week an agent upgrades your Vite React app's packages with yarn, runs yarn test and yarn build, drops what breaks, and opens one pull request.
Upgrade npm Dependencies in a Vue App: Yes. An agent updates your Vue app's pnpm catalogs every week, runs pnpm test and pnpm build on Node 22 and 24, and opens one PR minus the bumps that fail.
Upgrade Nuxt and Its Modules in a Nuxt App: An agent upgrades Nuxt and its modules with pnpm and nuxi, keeps bumps that pass lint, typecheck and build, and opens a pull request with one line per change.
Upgrade Flutter Packages in pubspec.yaml: Yes. An agent upgrades your Flutter app's pub packages in groups, moves exact pins and majors deliberately, runs flutter analyze and flutter test, and opens one PR.
Upgrade Python Dependencies in a Streamlit App: Yes. Each week an agent upgrades a Streamlit app's requirements with pip, runs AppTest and ruff after each group, and opens one pull request.
Upgrade a FastAPI App to Python 3.14: Yes. An agent moves your FastAPI app to Python 3.14, runs pytest with warnings as errors, fixes each deprecation and opens a pull request.
Upgrade a Flask App to Python 3.14: Yes. An agent installs your Flask app on Python 3.14, bumps the pins that lack wheels, fixes each warning the tests raise and opens a pull request.
Upgrade Quarkus to the Latest Release: Yes. An agent runs quarkus update on your service, applies the code changes it suggests, runs ./mvnw verify, and opens a PR that says what moved and why.
Upgrade Symfony and Its Dependencies: Send a Symfony dependency upgrade to an agent that checks Composer constraints, runs PHPUnit, and returns a reviewable pull request.
Upgrade Terraform Providers in a Terraform Module: Yes. An agent raises your module's provider constraints, validates every example on the new versions, fixes deprecated arguments and opens a pull request.
Upgrade Python Dependencies with uv in a FastAPI App: An agent upgrades a FastAPI app's uv dependencies, checks them against PostgreSQL, and returns a pull request explaining every retained bump.
Upgrade a VS Code Extension to the Latest API: Yes. A Rush agent raises engines.vscode and @types/vscode together, compiles, runs the extension tests in VS Code under xvfb and opens a pull request.
Upgrade Wagtail to the Latest Release: An agent checks Wagtail and Django compatibility, updates the site's requirements, and returns an upgrade PR with system and test output.
Triage New Sentry Issues Every Week: Yes. Each week an agent reads new and regressed Sentry issues, groups shared root frames, ranks them by users affected and names a likely cause.
Write a Weekly Incident Summary From Datadog: Yes. Each week an agent reads Datadog incidents and triggered monitors and writes incidents.md with durations, services, repeat offenders and trends.
Get a Weekly Product Metrics Report From PostHog: Yes. Each week an agent pulls active users, signups, activation and top events from PostHog and writes metrics.md with changes and the query behind each.
Write a Weekly Project Status From Asana: An agent reads Asana project tasks, writes a weekly status report and posts the requested project updates without changing the tasks themselves.
Write a Weekly Reliability Report From Grafana: Yes. Each week an agent queries request rate, error rate and p95 latency in Grafana and writes reliability.md with the changes and the PromQL behind them.
Send a Weekly Stripe Revenue Digest to Slack: Yes. An agent totals your last seven days in Stripe, writes the full digest as a file, and sends a five-line version to you in Slack.
Roll Up Weekly Status From Notion Pages: Yes. Each week an agent reads the Notion project pages and notes edited that week and writes one status page with progress, risks and decisions, linked.
Send a Personal Welcome Email for Each Signup Through an API: Yes. Your backend starts one run per signup; the agent reads the company's site and sends a short personal welcome through your Resend account.
Inventory Cloudflare Workers and Their Bindings: An agent reads Cloudflare Workers, routes and storage bindings and returns an inventory with routing gaps and unbound storage flagged for review.
Write Tests for a Custom GitHub Action: Yes. An agent writes Jest tests for every input and failure path of your TypeScript action, rebuilds dist with npm run all and opens a pull request.
Write Tests for an Actix Web API: Yes. An agent writes actix_web::test handler tests against a real Postgres in its sandbox, covers success and error responses and opens a pull request.
Write Unit Tests for an Angular App: An agent adds Angular TestBed coverage for untested services and HTTP interceptors, runs the existing test runner, and returns a pull request.
Write API Tests for a Django REST Framework API: An agent maps DRF endpoints, adds APIClient tests against the real test database, and returns a PR covering permissions, validation and pagination.
Write API Integration Tests for a Hono App: An agent tests Hono routes through the real application and storage layer, covering successful requests, validation, auth failures and missing records.
Write API Integration Tests for a NestJS App: Yes. An agent starts your NestJS API against a real database in its sandbox and writes tests that call every endpoint, including auth and validation errors.
Write Tests for a Streamlit App: Yes. An agent writes pytest tests with Streamlit's AppTest for each page of your app, runs them headless in its sandbox and opens a pull request.
Write Tests for an AWS CDK App: Yes. An agent writes aws-cdk-lib/assertions tests and a snapshot for your CDK stack, runs them with no AWS account and opens a pull request.
Write Tests for a Go CLI: Yes. An agent writes Go tests for your CLI's flags, config loading and input sources, adds golden-file output tests, runs go test ./... and opens a pull request.
Write Integration Tests for a Rust CLI: Yes. An agent writes assert_cmd integration tests and snapshot tests for your Rust CLI, runs cargo test in its sandbox and opens a pull request.
Write Component Tests for an Expo App: An agent finds Expo components with meaningful state or conditional rendering, adds user-focused tests, and returns a PR with Jest results.
Write Component Tests for a Svelte App: Yes. An agent adds Vitest with jsdom and Svelte Testing Library, tests the five components that hold the most state as a user would, and opens a pull request.
Add Smoke Tests to a Docker Compose Stack: Yes. An agent adds a health check to every Compose service and a smoke test that brings the stack up with --wait and calls each endpoint, then opens a PR.
Write dbt Data Tests: Yes. Each night an agent adds unique, not_null, relationships and accepted_values tests to untested dbt models, runs dbt build on DuckDB and opens a pull request.
Write Tests for a Django App: Yes. An agent finds thin spots in a Django app's TestCase suite, writes tests for untested branches, runs manage.py test, and opens a PR.
Write Playwright Tests for an Electron App: Yes. An agent writes Playwright tests that launch your built Electron app, check the window and an IPC round trip, run them under xvfb and open a PR.
Write Tests for Firebase Cloud Functions: Yes. An agent writes tests that run your Cloud Functions against the Firebase emulators, covering the trigger and its failure paths, then opens a PR.
Write Tests for a Chrome Extension: Yes. An agent writes Jest tests for your extension's popup, options page and service worker with the chrome APIs mocked, runs npm test and opens a pull request.
Write Integration Tests for a VS Code Extension: Yes. An agent adds @vscode/test-cli integration tests that boot a real VS Code, open your tree view and run its commands under xvfb, then opens a PR.
Write ExUnit Tests for a Phoenix App: Yes. An agent finds the plugs, controllers and components in your Phoenix app with no test file, writes ExUnit tests in the project's own style and opens a PR.
Write Tests for a Filament Admin Panel: Yes. An agent writes Pest tests with Filament's Livewire helpers for the resources and relation managers that lack them, runs the suite and opens a PR.
Validate a GitOps Repository Before Argo CD Syncs It: Yes. An agent renders every Kustomize and Helm app in your GitOps repo, validates the output with kubeconform in CI, and reports any app that fails.
Write GraphQL API Tests for a Spring Boot App: Yes. An agent tests every GraphQL query and mutation in your Spring Boot app, including auth and validation errors, on a real database and opens a pull request.
Write Unit Tests for a Helm Chart: Yes. An agent adds helm-unittest suites for your chart's templates, runs helm unittest and helm lint, and opens a pull request with the results.
Write an Incident Postmortem for a Kubernetes Outage: An agent reads your Grafana logs, the commits deployed in the window and the incident channel export, and writes a blameless postmortem with a sourced timeline.
Write Integration Tests for an ASP.NET Core API: Yes. An agent extends WebApplicationFactory tests against real Postgres for your Catalog API, runs dotnet test, and opens a pull request.
Write Jest Tests for a React Native App: Yes. An agent writes Jest and React Native Testing Library tests for your Expo screens and forms, runs them without a simulator and opens a pull request.
Write Jest Unit Tests for a NestJS API: Yes. An agent writes Jest specs for NestJS services that lack them, builds each with Test.createTestingModule, runs npm test, and opens a PR.
Write Tests for a Ktor Server: Yes. An agent adds testApplication coverage for registration, login, posting and deleting kweets, runs Gradle test, and opens a pull request.
Write Tests for AWS Lambda Functions in a Serverless Service: Yes. An agent writes Jest tests for each Lambda handler, runs them against DynamoDB Local in its sandbox, and opens a pull request. No AWS account needed.
Write LiveView Tests for a Phoenix App: Yes. An agent writes LiveViewTest cases for profile, uploads, playback and presence, runs mix test, and opens a pull request.
Write k6 Load Tests for an Express API: Yes. An agent writes k6 scripts for your Express API's main flows, ramps them against the service in its sandbox and reports p95 latency and the breaking rate.
Write k6 Load Tests for a FastAPI API: Yes. An agent writes k6 scripts for your FastAPI app's main flows, ramps them against the service in its sandbox and reports p95 latency and the breaking rate.
Write Load Tests for a Fastify API: Yes. An agent writes autocannon scripts for your Fastify API's main flows, runs them in its sandbox against a real database, and reports latency and errors.
Validate Kubernetes Manifests in CI: Yes. An agent adds kubeconform and kube-linter checks over your Kustomize and Helm renders, records findings, and opens a pull request without editing manifests.
Write System Tests for a Rails App: Yes. An agent writes Capybara system tests that drive your Rails and Hotwire app in headless Chrome, runs bin/rails test:system and opens a pull request.
Write Molecule Tests for an Ansible Role: Yes. An agent extends Molecule verify to assert Docker install, service state, group membership and Compose, runs molecule test, and opens a pull request.
Write node:test Tests for a Fastify API: Yes. An agent adds fastify.inject error-path tests with node:test against MySQL, runs npm test, and opens a pull request.
Write Vitest Tests for Nuxt Server Routes: Yes. An agent adds @nuxt/test-utils and Vitest coverage for server routes and composables, stubs TMDB at the network edge, and opens a pull request.
Write pgTAP Tests for a Supabase Database: Yes. An agent writes pgTAP tests for your Supabase migrations, row level security and vector search function, runs supabase test db and opens a pull request.
Write PHPUnit Tests for a Symfony App: Yes. An agent writes WebTestCase tests for a Symfony admin area, covering the security voter, form validation errors and CSRF, runs PHPUnit and opens a pull request.
Write Playwright Tests for an Angular App: Yes. An agent writes Playwright specs for your Angular app's key flows, runs them headless against ng serve in its sandbox, and opens a pull request.
Write Playwright Tests for an Astro Site: Yes. An agent builds your Astro site, serves the output, writes Playwright tests for the home page, posts, tags, search and RSS, and opens a pull request.
Write Playwright Tests for a FastAPI and React App: Yes. An agent extends Playwright coverage for a FastAPI and React app, runs the suite against Docker Compose, and opens a pull request.
Write Playwright Tests for a Gatsby Site: Yes. An agent builds your Gatsby site, serves the output, writes Playwright tests for the post list, post pages, prev and next links and the feed, and opens a PR.
Write Playwright Tests for a Laravel App: Yes. An agent sets up your Laravel app in its sandbox, writes Playwright specs for its key flows, runs them headless and opens a pull request.
Write Playwright Tests for a Next.js App: Yes. An agent writes Playwright specs for sign-up, sign-in and the pricing checkout redirect, runs them headless against next dev in its sandbox and opens a PR.
Write Playwright Tests for a Nuxt App: Yes. An agent extends a Nuxt app's Playwright suite from the home page to its search, listing, detail, genre and person pages, on every browser project.
Write Playwright Tests for a React Router App: Yes. An agent adds Playwright specs for a React Router app's routes, runs them headless against the dev server, and opens a pull request.
Write Playwright Tests for a SvelteKit App: Yes. An agent writes Playwright specs for your SvelteKit app's form actions and pages, runs them headless against vite dev, and opens a pull request.
Write Playwright Tests for a Symfony App: Yes. An agent writes Playwright specs for your Symfony app's sign-in, browsing and comment flows, runs them against the PHP server in its sandbox, and opens a PR.
Write Playwright Tests for a Vite React App: Yes. An agent extends Playwright coverage for discussion and comment flows in a Vite React app, runs them headless, and opens a PR.
Write Playwright Tests for a Vue App: Yes. An agent writes Playwright specs for your Vue app's main flows, runs them headless against the Vite dev server in its sandbox, and opens a pull request.
Write Property-Based Tests for a Python Library: Yes. An agent adds Hypothesis properties for core parsers, runs a high example count, and opens a PR without changing library code on failure.
Write Property-Based Tests for a Rust Crate: Yes. An agent reads your crate's public API and tests, writes proptest properties against a simple model, runs them under every CI feature set, and opens a PR.
Write Property-Based Tests for a Rust Library: Yes. An agent adds proptest properties for core parsers, runs a high case count, and opens a PR without changing library code on failure.
Write Property-Based Tests for a TypeScript Library: Yes. An agent adds fast-check properties for your library's core functions, runs them at a high example count, and reports any shrunk counterexample.
Write Unit Tests for a Pulumi Program: Yes. An agent writes Mocha unit tests with pulumi.runtime.setMocks for your Pulumi program, runs them without cloud credentials, and opens a pull request.
Write pytest Tests for a FastAPI App: Yes. An agent runs the FastAPI app's suite with coverage, writes tests for the untested summarizer, CRUD layer and config against a real Postgres, and opens a PR.
Write pytest Tests for a Flask App: Yes. An agent moves a Flask app from one unittest file to a pytest suite for its auth, posts, follow and API blueprints on a real test database, and opens a PR.
Write Tests for a Quarkus Service: Yes. An agent writes @QuarkusTest and REST Assured tests for your endpoints' error paths, runs ./mvnw verify against Dev Services, and opens a pull request.
Write RSpec Tests for a Rails App: Yes. An agent runs the suite under SimpleCov, finds the controllers with the thinnest coverage, writes request specs with your factories and opens a pull request.
Write Integration Tests for an Axum API: Yes. An agent writes tests under tests/ that call every Axum route through tower's oneshot against a real Postgres, runs cargo test and opens a PR.
Write Tests for a Rocket Server: Yes. An agent adds unit tests for your Rocket server's pure helpers and local-client tests for its open routes, runs cargo test and opens a pull request.
Write Supertest Tests for an Express API: Yes. An agent maps your Express routes and middleware to the tests that exist, writes Supertest cases for the gaps against a real MongoDB, and opens a PR.
Write Terraform Tests for a Terraform Module: Yes. An agent writes .tftest.hcl files that plan your module against mock providers, runs terraform test with no cloud credentials and opens a PR.
Write Testcontainers Tests for a Spring Boot App: Yes. An agent writes Testcontainers tests that boot your Spring Boot app against real MySQL and PostgreSQL containers and exercise it over HTTP, then opens a PR.
Write Unit Tests for an ASP.NET Core Project: Yes. An agent runs coverage on an ASP.NET Core API, adds xUnit tests for the thinnest logic files, and opens a pull request with the delta.
Write Unit Tests for an Elixir Project: Yes. An agent runs mix test --cover on the Elixir project, picks the modules the report leaves thin, writes ExUnit tests with the project's own cases and opens a PR.
Write Unit Tests for a Gin Project: Yes. An agent runs the Gin project's coverage script, finds the functions it leaves uncovered, writes Go testing tests for them and opens a PR with the delta.
Write Unit Tests for a Go Project: Yes. An agent runs Go coverage, adds testing package tests for the least-covered logic files, and opens a pull request with the delta.
Write Unit Tests for a Laravel Project: Yes. An agent runs Pest coverage on a Laravel app, adds tests for the thinnest logic, and opens a pull request with the before and after.
Write Unit Tests for a Rust Project: Yes. An agent runs Rust test coverage, adds tests for the least-covered logic modules, and opens a pull request with the coverage delta.
Write Unit Tests for a Spring Boot Project: Yes. An agent runs JUnit 5 coverage on a Spring Boot API, adds tests for the thinnest logic, and opens a pull request with the delta.
Write Tests for a Vapor Server: Yes. An agent writes VaporTesting route tests for your Swift server against an in-memory SQLite database, runs swift test on Linux and opens a PR.
Write Vitest Tests for a Next.js App: Yes. An agent wires Vitest into a Next.js app with no tests, tests session signing and the Drizzle queries against a real Postgres, and opens a pull request.
Write Vitest Tests for React Router Loaders and Actions: Yes. An agent adds Vitest to your React Router app, calls each loader and action with a real Request, checks data and redirects, and opens a PR.
Write Vitest Tests for a SvelteKit App: Yes. An agent adds Vitest to your SvelteKit app, tests its load functions and form actions with real Request objects, runs them and opens a pull request.
Write Vitest Tests for a Vite React App: Yes. An agent finds the least-tested features in your Vite React app and writes Vitest and Testing Library tests for their loading, error and empty states.
Write Vitest Tests for a Vue App: Yes. An agent writes Vitest and Vue Test Utils tests for your untested Vue components and Pinia stores, including the language switch, and opens a PR.
Write Tests for a Wagtail Site: Yes. An agent writes WagtailPageTestCase tests for your page models: where each page may be created, which children it allows, and that each one renders.
Write Widget Tests for a Flutter App: Yes. An agent creates your Flutter app's first test/ directory: widget tests for its main screens and go_router navigation, plus a golden test.
Write Vitest Tests for a Cloudflare Worker: Yes. An agent writes Vitest tests that run your Worker inside workerd with a local D1 database and its migrations applied, then opens a pull request.