Engineering skills

Design and BUILD the backend service surface, REST/GraphQL/RPC API design (contract-first OpenAPI/GraphQL, resource + verb + status-code design, consistent response envelopes, cursor pagination, versioning), end-to-end input validation (Zod), object- + tenant-level authorization (no IDOR), typed error taxonomy, idempotency + rate limiting, queued background work (BullMQ).

Standards that make an app feel fast: cached/deduped data layer instead of fetch-on-mount, navigation that never dead-ends, honest loading/empty states, optimistic mutations, and measurements. Framework-agnostic.

Design and build the async work layer beneath the API, move slow, external, or bursty work off the request into a durable job queue.

Review a diff or PR for correctness, performance, readability, and maintainability on the Next.js/TS/Prisma stack (N+1 queries, error handling, edge cases, missing tests) and route security-sensitive surface to the appsec review.

Understand an unfamiliar codebase fast, get a navigable map of how every file, function, and dependency fits together. A real parser (tree-sitter/AST) extracts the structural graph (imports, defs, calls, inheritance) as ground-truth facts; an LLM layer adds summaries, layer grouping, and code→domain mapping (labeled interpretation).

Run engineering as a compounding loop where each unit of work makes the next easier, ~80% planning + review, ~20% execution.

Design the data model + database schema BEFORE the API, model the domain (entities, attributes, relationships), draw the ERD, normalize then denormalize on purpose, pick stable keys + correct types (numeric money, timestamptz, enums), index every FK + query path, enforce integrity IN the database (unique/check/FK constraints, ON DELETE behavior).

Run a structured debugging session on the Next.js/TS/Prisma/Vercel stack, reproduce, isolate, diagnose root cause, fix minimally, and add the regression test that prevents it.

Remove code, features, endpoints, and systems safely, code is a liability and deleting it is an underrated win, but ripping it out blindly breaks consumers you forgot about.

Adversarially verify the agent's own confident output before committing, the most dangerous output is the one it's surest about.

Build an eval harness that proves a prompt, skill, agent, or workflow actually works (and stays working) turning "this seems better" into a measured score on a held-out test set.

Design and build the file-upload and media pipeline, take large uploads direct to object storage with short-lived presigned URLs instead of proxying them through the app server.

Manage Agency Script OS git workflow for isolated feature work and branch completion. Inspect dirty state without reverting user changes, choose current branch vs codex/* branch vs git worktree, stage only owned edits, make atomic conventional commits with no AI attribution, prepare PR/merge options, and clean up safely.

Engineering category hub: routes to the right leaf for building (data model, API backend, background jobs, realtime, file uploads, RAG, MCP server), changing safely (refactor, tech debt, deprecation, migration, debug, performance), and proving it works (testing strategy, webapp testing, evals, code review, verify-before-done, doubt-driven). Entry point for the engineering domain.

Design, build, and harden an MCP server so an agent can actually use it, tool surface sized to the job, schemas that fail loudly, responses shaped for a model rather than a REST client, auth and metering, and an agent-run evaluation instead of a green unit test.

Optimize application performance the measure-first way, reproduce the slow case, profile to find the real bottleneck, fix that one dominant cost, re-measure to prove the win, and guard against regression. Never optimize from intuition; the hot path is almost never where you think.

Build a retrieval-augmented generation (RAG) system that grounds an AI on your own data. So it answers from real, cited sources instead of its training priors.

Design and build the realtime layer, push live updates to the browser instead of polling, over the right transport.

Execute a safe, behavior-preserving refactor on a working app, pin behavior with characterization tests, find the seams, then run the named workflow (god-file split, duplication collapse, state untangle, boundary extraction, strangler-fig replacement, AST codemod sweep, type hardening) in small reversible steps that stay green, never mixing a refactor with a behavior change.

Ground every framework, library, or API decision in the official source instead of memory. So the agent never hallucinates a method, option, config key, or version behavior that doesn't exist.

Generate a truthful standup update (yesterday / today / blockers) synthesized from recent commits, PRs, and ticket movement, not aspirational filler.

Identify, categorize, and prioritize technical debt across the Next.js/TS/Prisma codebase into a ranked refactor backlog by impact × effort. Not a rewrite-everything wish list.

Design a test strategy/plan for a feature or the app and write the tests, the pyramid (Vitest unit/integration, Playwright e2e) tuned to this stack, coverage that matters on money/auth/render paths, and the actual test code.

A hard pre-completion gate that blocks any "fixed / passing / shipped / done / works" claim without fresh runtime evidence, matching the evidence class to the claim type, demanding it be produced this session after this change, reading the actual output instead of pattern-matching it, and labeling honestly anything that could not be verified. Attacks the fake-success pattern.

Test a running web app end to end with Playwright (drive real browser flows (signup, login, checkout, forms, dashboards), assert on visible state, capture screenshots/console/network on failure, and check responsive + basic a11y) then hand back a runnable spec + a triaged failure report. For verifying a live local/staging app behaves, not unit tests.

Inspect any digital surface to Tesla Highland fit-and-finish (gaps, paint, NVH, interior, crash structure) and return a blocker-scored card. PPL vehicles stay as-ops-lead-gen-tesla-build; chrome build stays as-ops-premium-ui-builder; design system freeze stays as-design-system-architect.

Static coherence QA for any Next.js/React app, is it NAVIGABLE, CONSISTENT, and WIRED? Runs a repeatable 8-pass scan (route inventory, internal-link integrity, nav reachability/orphan routes, design-token + CTA-primitive drift, multiline-aware form wiring, metadata/SEO coverage, static a11y, hygiene + shadow routes) and returns severity-tiered findings with file evidence.