Addy Osmani

Reviews your endpoint shapes, versioning strategy, and type contracts. Spots versioning debt, over-coupling, and breaking changes before they ship.

Examines a PR or code snippet across security, performance, maintainability, and test coverage—surfacing gaps and risks the eye misses before it ships to main.

Diagnoses why an agent is losing quality (bad context, conflicting rules, task bleed), then rewrites the system prompt and rules file to restore focus and accuracy.

Maps out the timeline and communication cadence for sunsetting old code or APIs, identifies affected users, and drafts the migration path with a go-dark date.

Writes clean component code and handles layout, state, and styling so the interface feels intentional—not like an AI sketch. Outputs are ready to ship.

Reviews your codebase and metrics, identifies the 2–3 bottlenecks driving slowness, and recommends concrete fixes ranked by impact and effort.

Reviews code that touches user input, auth, or third-party APIs and flags OWASP-class vulnerabilities — injection, XSS, credential leaks — with a fix for each.

Fetches official docs for any library or framework, then writes code snippets and full implementations that cite the exact section they're based on—no outdated Stack Overflow patterns.

Scaffolds a complete pipeline config (GitHub Actions, GitLab CI, or Jenkins) with test runners, quality gates, and deployment stages tuned to your repo structure.

Presents your code choice or architectural decision to a fresh critic who finds gaps, edge cases, and unstated assumptions you'd otherwise catch in production.

Suggests branch naming, commit message structure, and merge strategy so parallel work doesn't tangle. Handles conflict resolution and multi-stream coordination.

Takes a feature spec or requirements doc and produces a task breakdown with dependency arrows, effort estimates, and a clear "start here" — so a team knows what to parallelize and what must wait.

Takes a vague feature idea or user problem and produces a detailed spec with acceptance criteria, edge cases, API contracts, and data models — before a line of code is written.

Catalogs all available skills and matches your task to the best one, explaining what it does and how to invoke it. A reference layer for skill discovery.

Captures architectural choices, API changes, or feature ships as an ADR or doc that explains the "why" alongside the "what" — so future engineers understand the context.

Reads a requirement or bug report and writes failing tests first, then implements the minimal code to pass them. Forces clarity on what "done" means before you code.

Takes a half-formed concept and stress-tests the assumptions, expands alternative angles, then converges on a specific direction with concrete next steps you can act on.

Opens a real Chrome browser, inspects the DOM, captures console errors, analyzes network requests, and profiles performance—all from Claude, with actual runtime data instead of guesses.

Asks one clarifying question at a time until it understands your real problem, not your first-draft solution. Stops when confidence hits 95%.

Takes a working but messy function or module and rewrites it to be easier to read and maintain, keeping behavior identical. Flags assumptions and suggests test cases.

Reads an error log or stack trace and guides you through isolating the root cause step-by-step, narrowing scope until the fix becomes obvious.

Takes a large feature or refactor and splits it into a sequence of small, working commits—each one testable and reviewable independently without breaking the main branch.

Builds a ship checklist tailored to your app—monitoring setup, staged rollout plan, rollback strategy, comms timeline. Catches the gotchas before they're live.