What We're Looking For
The core of the job is the work above: shipping products, end to end. These describe the essential functions of the role; we welcome candidates who perform them with or without reasonable accommodation.
Required:
- 6 years of software engineering (or equivalent demonstrated depth), with React and TypeScript fluency deep enough to spot a stale closure or a re-render storm in a diff you didn't write.
- 1 years of substantial hands-on work with agentic coding tools where the stakes were real: production work or sustained serious use where you owned the consequences of merged output. Any tool where the agent edits files, runs commands, and you review the result counts
(Claude Code, Codex, Cursor agent mode, Aider, or equivalent).
- You've taken features from an underspecified ask all the way through QA. Part of the work was figuring out what the ask actually meant.
- An AI failure got past you once, and you built a mechanism because of it: a lint rule, CIgate, or convention change that catches that failure class now. We'll ask to see it before the loop. Anonymized is fine; we will never ask you to violate an NDA, and inability to name employers or systems won't count against you.
- Able to write clear specs, acceptance criteria, and decision logs. That's how work gets directed here.
- You've written agent-facing convention rules (CLAUDE.md style) and revised them when the agent kept slipping.
- You've built developer tooling: lint rules, CI gates, code mods, review automation.
AST-based beats regex here.
- Multi-agent verification you designed yourself, plus a defect the adversarial pass caught that the producing agent insisted was fine.
- You've shipped user-facing features at a pace the agent loop made faster and can talk about the product impact.
- Behavior-driven development (BDD) / spec-first habits; comfort with Playwright tor similar for real-browser verification.
We've rebuilt our development process around agentic AI tooling (Claude Code, Codex): most code here is written with an agent and reviewed by a human who owns it completely. You own the code regardless of how it was written. When something does break, we fix whatever allowed it to make it through - usually a missing check or a bad convention. You'll spend most of your week building products: design, feature work, and the judgment calls agents can't make. Hand-writing code is still normal here when it's the right tool. What You'll Do
- Design and build features across the stack: React UIs from design specs, API’s in Node.js, data models, and the wiring between them.
- Own delivery end-to-end in our React 18 / TypeScript / Node.js mono repo, from ambiguous requirement through QA handoff. Figuring out what the ask actually means is part of the job.
- Make architecture calls and write them down, discuss with our architect. Specs and decision logs are how the team stays aligned, and how the agents get directed.
- Run the agent loop for the well-specified, mechanical parts: write the brief, then review the output for the defect classes that actually show up (weakened tests, vacuous assertions, plausible-but-wrong logic, silent convention deviations) and verify with evidence. A green test run doesn't tell you much on its own; trigger the failure case on purpose and watch the guard catch it.
- Build guardrails when an agent makes the same mistake twice: convention rules, AST-based lint gates, CI checks. Nobody should remember to watch it for a third time.
- Maintain pattern discipline. No silent one-off deviations. When you find an existing one, surface it instead of adding another. Page 1 | 2 Job Description: Sr. Software Engineer What We're Looking For The core of the job is the work above: shipping products, end to end. These describe the essential functions of the role; we welcome candidates who perform them with or without reasonable accommodation. Required:
- 6 years of software engineering (or equivalent demonstrated depth), with React and TypeScript fluency deep enough to spot a stale closure or a re-render storm in a diff you didn't write.
- 1 years of substantial hands-on work with agentic coding tools where the stakes were real: production work or sustained serious use where you owned the consequences of merged output. Any tool where the agent edits files, runs commands, and you review the result counts (Claude Code, Codex, Cursor agent mode, Aider, or equivalent).
- You've taken features from an underspecified ask all the way through QA. Part of the work was figuring out what the ask actually meant.
- An AI failure got past you once, and you built a mechanism because of it: a lint rule, CI gate, or convention change that catches that failure class now. We'll ask to see it before the loop. Anonymized is fine; we will never ask you to violate an NDA, and inability to name employers or systems won't count against you.
- Able to write clear specs, acceptance criteria, and decision logs. That's how work gets directed here. Strong signal:
- You've written agent-facing convention rules (CLAUDE.md style) and revised them when the agent kept slipping.
- You've built developer tooling: lint rules, CI gates, code mods, review automation. AST-based beats regex here.
- Multi-agent verification you designed yourself, plus a defect the adversarial pass caught that the producing agent insisted was fine.
- You've shipped user-facing features at a pace the agent loop made faster and can talk about the product impact.
- Behavior-driven development (BDD) / spec-first habits; comfort with Playwright or similar for real-browser verification.
