Product Engineer

Product.ai; Los Angeles (CA); On-site; USD 325,000 - 425,000; Full time

Benefits offered by this job

Relocation support

Job summary

Product.ai in Santa Monica, CA, is seeking a product engineer who ships end-to-end consumer surfaces using TypeScript and React. You will own the product call, the spec, the build and the ship, directing agents to write code and verifying outcomes against the spec.

You have shipped real products, owned outcomes, and can defend product calls with data and clear specs. This role blends product, design, and engineering in a fast, bootstrap startup setting.

Qualifications

• Experience shipping consumer-facing software that users actually interact with.
• Ability to defend product decisions with data and clear rationale.
• Strong background in frontend development using modern JS/TS tooling.

Responsibilities

• Own one consumer surface end to end: experience, metrics, roadmap and build.
• Define the spec and gate for the surface and guide agents building against it.
• Verify agent-written code against the spec and test results.
• Balance user needs, data signals and product taste when making calls in gray areas.
• Collaborate with design and engineering to ship high-impact experiences.

Skills

TypeScript

React

Product ownership

Shipping product

Frontend engineering

Job description

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.

Role Overview

Compensation $325k - $425k

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 (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 (simplycodes.com) 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.
• 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.
• 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.

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.

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.

Selection Protocol

To ensure alignment, complete these steps in order.

Read: Culture Guide (Required)

Understanding our operating principles is essential before starting.