Product Engineer

You own one Product.ai consumer surface end to end: the product call, the spec, the build and the ship. Agents write most of the code. You own the verdict on whether it's right.

Product.ai is the verified truth layer for shopping: when a person or an AI agent needs to know what's actually true about a purchase, we answer with proof. SimplyCodes is the first proof at scale, the code verification service, at about $22M a year in revenue. Profitable. Founder-owned since 2009, bootstrapped, no outside investors, no board. Fewer than twenty operators.

Why This Role Exists

Product.ai has more consumer surfaces than owners. We're hiring product thinkers through several doors, and this is the engineer's door: someone who came up writing code, has shipped things people use, and now wants to own the product outcome instead of the ticket.

A product engineer here decides what to build and how they'll know it worked. You weigh the data, the user and your own taste, make the calls in the gray area, write the spec, and direct the agents that write most of the code. Then you verify what came back, because an agent's output is something you check, never something you accept.

Your surface is one no one here holds yet, and two are waiting for an owner. The first is the consumer experience inside the AI platforms that now show our answers: what a person sees and does when ChatGPT, Siri, Gemini or Claude hands them a Product.ai verdict. The second is personalization: a shopper's own constraints and preferences, remembered and applied to every verdict they get. Which one is yours is the first conversation with the founder, and we write the answer down. The interface contract those platforms call belongs to our technical product seat; what a person sees and does once the answer arrives belongs to you.

The System You'll Need to Model

• Decision-shaped consumer interfaces. The unit of our product is a verdict, not a chat transcript: what's true, the evidence behind it, how sure we are, and when the honest answer is "don't buy." The user changes a constraint and watches the verdict move. Streaming, citation-bearing, trust-critical: one wrong claim rendered confidently costs more than a month of speed.
• A product inside someone else's platform. Building a consumer experience inside ChatGPT, Apple's App Intents, Gemini or Claude is the same craft class as building for an app store or a browser, with one difference: an AI decides when to show you. The host owns the layout, the moment and what you may render. You own what a person can do once they're there.
• Preference-aware answers. A verdict that remembers what this shopper cares about is a different product from one that doesn't. It's a data model, a consent and trust problem, and an interface problem at once, and the three have to be designed together.
• A spec-driven agentic build pipeline. Intent becomes a visual mockup, then a locked spec, then agents build against it in unattended runs of one to four hours, then separate verifier agents grade the build against the spec. The building agent never grades its own work. Your spec is the interface the whole loop builds and grades against, so your judgment is the gate, not your keystrokes.
• Several surfaces, one system. Web, browser extension, assistant platforms and the design system that spans them: different interaction contracts, one truth backend, one set of components. A component decision on your surface is an architecture decision on the others.
• Cortex, the shared AI brain the company runs on. You'll work inside it daily, directing coding agents the way our founder does, and since August any operator here can change the rules the company runs on, live, without waiting on him.

If reading that energizes you, keep going. If it feels overwhelming or underspecified, this isn't the right fit.

What You Will Own

• One consumer surface, end to end. The experience, the metrics, the roadmap and the build, owned the way a founder owns a product. Your surface carries falsifiable outcomes, each with an evidence test a stranger could run.
• The product calls in the gray area. Most decisions on a consumer surface have no clean data answer. When does a confidence indicator build trust, and when does it plant doubt? When is "don't buy this" the right thing to render boldly? You weigh the data, the user and your taste, and you decide. What's visible here is decisions registered and outcomes moved.
• The spec and the gate. With our Founding Designer, who owns the design system and the mockup-before-code gate, you run the discipline that everything on your surface gets seen before it gets built. You write the spec agents build from and the acceptance tests that decide whether a long unattended run shipped the right thing.
• Verification for agent-written product code. You define what "correct" means for a streaming, citation-bearing interface and make that definition executable: verifier agents, evaluation suites for interface behavior, gates that catch drift before a shopper sees it. Almost no one shipping with agents has built this well yet.
• Your seat charter. Within your first quarter you co-sign a charter for this seat. It names one machine-checkable number that proves the seat is working, and a written split of what you decide freely versus what you bring to the founder.

The craft you must already own: shipping consumer product to real users in TypeScript and React, and making product calls you can defend. Comparable experience we accept: senior full-stack or frontend work with real product ownership, a founding engineer seat at a consumer company, or a product you built and shipped on your own. What you'll grow into here: directing coding agents as your production system, evaluation design for interfaces, and distribution through AI assistants, which is becoming what app-store distribution was.

Who You Are

How you think. You form a working model of a system you didn't build, a truth backend, a multi-surface frontend, an agent loop, and you notice fast when the model is wrong and update without ego. You don't wait for scope to be perfectly defined; enough signal and first principles get you moving. You write clearly, because a clear spec is what turns your judgment into something agents can build and be graded against.

How you work. You move between product strategy and shipped code without getting stuck at either altitude: a user problem in the morning becomes a mockup by noon and a verified change in production by evening. You treat agents as leverage you verify. You can still do the whole job by hand, and that mastery is what lets you trust or reject the code an agent hands you. Compute is cheap here; a redo cycle from a vague spec is what costs.

What you've probably built. Consumer products with real users, where you can point to the product calls you made and what happened after: a streaming interface, a design system, an evaluation harness for AI output, an agent workflow you built because you needed it. Adjacent roads count: platform apps, browser extensions, developer tools with a consumer edge. We care about the artifact and the reasoning more than where you did it.

Who this isn't for. This is wrong if you wait for a spec to start; here you write the spec. It's wrong if you measure yourself in code authored rather than outcomes shipped, because most of the code here is written by agents you direct. It's wrong if you want a narrow lane; a consumer surface is product judgment, design collaboration, engineering and verification in one seat. It's wrong if your code is whatever the model handed you and you couldn't say why it's right, or if you're comfortable letting an agent grade its own work. You'll be happiest here if you want the whole problem and want to be measured on what your surface does for the people using it.

How We Evaluate

We don't run traditional engineering interviews.

Async video screen. About 15 minutes, on your own time. It replaces the recruiter screen. We want to see how you think, not how you present.

Calls with company stakeholders. Short conversations with the people you'd build beside.

Conversation with the founder. Product taste, how you model the systems above, how you reason in the gray area.

Paid work trial. Four days of real work in our real environment, code that ships to production. We watch how you get grounded, whether you write the spec before the build, how you verify what your agents produce, and whether your self-assessment is honest.

If the work above reads like yours but your resume is unconventional, apply anyway. We hire on the work and the reasoning, not the pedigree.

Compensation & Ownership

Total first-year comp: $325,000 to $425,000 (base + performance-based ownership and profit-share programs). Base: $200,000 to $260,000.

Beyond base: eligibility for the company's ownership and profit-share programs, grants are performance-based, terms discussed at the offer stage; 100% family premium coverage; and an effectively unlimited token budget, steered by return, never capped.

Based in Santa Monica, Los Angeles, in person, five days a week. Relocation support available for the right builder.