Product Engineer

Product.ai; Los Angeles (CA); Hybrid; USD 200,000 - 260,000; Full time

Benefits offered by this job

Equity participation

Profit sharing

Unlimited token budget

100% family premium coverage

Job summary

Product.ai in Los Angeles is seeking a Product Engineer who will own the consumer product experience from concept to execution. In this role, you'll use your technical judgment to direct agents as they build and refine product features. The position offers competitive compensation ranging from $325,000 to $425,000, including equity, with the potential for remote work.

Ideal candidates will have a strong background in product management, technical writing, and system modeling, alongside the ability to analyze data and make informed product decisions.

Qualifications

• Proven ability to own and manage product lifecycle end to end.
• Strong judgment in decision-making regarding product features.
• Experience in building consumer-facing products.

Responsibilities

• Own the chat truth experience and product judgments.
• Direct agents in building user interfaces efficiently.
• Define quality metrics for agent-written code.

Skills

Product management

Technical writing

System modeling

Data analysis

Job description

Own a consumer surface end to end — the product calls, the spec, the build, the ship. Your leverage is judgment and taste.

Product.ai is the verified truth layer for shopping — the intelligence that tells you what's actually true about a product, including when not to buy. Profitable. Bootstrapped. No outside investors. No board. 20 people outbuilding companies 10× our size.

Strong people find us and keep finding us — they apply over months and years, because the field moves fast and the exact profile we need moves with it.

Why This Role Exists

A Product Engineer here is a builder with a high technical bar whose real leverage is judgment — closer to a product engineer who owns the whole problem than a coder taking tickets. You decide what to build and how you'll know it worked. Here, every consumer surface is owned end to end by one person: you weigh the data, the user, and your own product taste, make the calls in the gray area, write the spec, and direct the agents that write most of the code. Agents write the code. You own the verdict on whether it's right. Your first surface is our flagship: the chat truth experience, where a shopper asks a high‑stakes question and gets a verdict with the evidence behind it — and the ability to reshape the question and watch the verdict change.

The System You'll Need to Model

The following are the system components you will model.

• A consumer truth experience where the UI's job is decision‑shaped answers: verdicts, not chat transcripts. It renders what's actually true about a product, with the evidence, and lets the user reshape the question and watch the answer move. Streaming, citation‑bearing, trust‑critical: one wrong claim rendered confidently costs more than a month of velocity gains.
• The build pipeline: visual mockup before code, spec locked, then long‑lived agent runs build against it — governed by our architectural law, a three‑tier system of constitutional rules, specs, and code with deterministic gates that fire when work is promoted. We run these as unattended 1‑4 hour loops; your judgment is the gate, your keystrokes are not.
• Verification at velocity. When agents write most of the frontend, the review wall is the real constraint — and you design what makes it scale: separate verifier agents that grade the work (the agent never grades itself), eval suites for UI behavior, gates that catch drift before it ships. Your agents query our shared knowledge base to answer their own questions, so your time goes to verdicts, freed from spoon‑feeding context.
• A multi‑surface architecture — web, browser extension, ChatGPT app, mobile — one design system, one truth backend, four very different interaction contracts. A component decision on one surface is an architecture decision on all four.
• The evolution pace. We ship in days; the system you model this quarter will be a different system next quarter. Token budget is effectively unlimited and steered by ROI, never capped — because the expensive thing is a redo cycle, never tokens. You model where the product is going and move.

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

What You Will Own

• The chat truth experience, end to end. You own it the way a founder owns a product — the experience, the metrics, the roadmap, the build — and you own falsifiable outcomes, each with an evidence test a stranger could run.
• 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 create doubt? When is 'don't buy this' the right answer to render boldly? You weigh the data, the user, and your taste — and you decide. What's visible is registered architecture decisions and outcome movement — the systems you shipped and how you knew they worked.
• The mockup‑before‑code gate. With our Founding Designer, you run the discipline that everything gets seen before it gets built: mockup first, spec locked, then the agents build. You own the spec quality that determines whether a long unattended run lands clean or wanders.
• Quality and eval gates for agent‑written UI code. You define what 'correct' means for a streaming, citation‑bearing interface and make that definition executable — so the review wall scales with the velocity. Almost no one shipping with agents has built this; you will.

Who You Are

You can do this job by hand, and prove it — directing agents without mastery falls apart; depth is what lets you trust the verdict an agent hands you. You treat agents as leverage you verify. You independently form working models of complex systems — a truth backend, a four‑surface frontend, an agent loop — and you notice fast when your model is wrong and update without ego. You move fluidly between product strategy and shipped code: a user problem in the morning becomes a mockup by noon and a verified change in production by evening. You have taste and strong opinions about what a trustworthy interface looks and feels like, and you defend them with evidence about the person using it, grounded in how the interface actually behaves. You write clearly, because clear writing is what locks a spec into law — and the spec is what your agents build against. You've shipped consumer products with real users, and you can point to the product calls you made: a streaming interface, a design system, an eval harness for AI output, an agent workflow you built because you needed it. The artifact and the reasoning matter more than where you did it.

Who this isn't for. This isn't for you 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, since most of the code here is written by agents you direct. It's wrong if you think in projects, timelines, and phases instead of shipped verdicts. It's wrong if you want a narrow lane — a consumer surface is product judgment, design collaboration, engineering, and verification in one seat. And 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. The question is never whether you use agents — everyone good does now — it's whether you can verify what they produce.

How We Evaluate

We don't run traditional engineering interviews.

• Written artifact. A live URL to something you shipped, a spec you wrote before a build, or a system you built and the hardest failure you personally diagnosed in it — and what you changed. Writing quality is the first filter; clear writing is how specs become law here.
• Video screen. Brief and async: 5‑6 questions, about 15 minutes, whenever works for you. How you think, not a trivia quiz.
• Calls with company stakeholders. Short conversations with key members of the team.
• Conversation with the founder. Product taste, how you model the system 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 ground yourself, 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 – $425,000 (base + equity + profit sharing).

Base: $200,000 – $260,000. Top of market for product engineering.

Profits Interest Units (PIUs) — Class B Membership Interests at $0 strike, real ownership day one, capital‑gains treatment; annual pro‑rata profit sharing from free cash flow; annual tender liquidity; 100% family premium coverage; effectively unlimited token budget, steered by ROI, never capped.

This is a partnership structure. When the company wins, you win — in real, liquid dollars, every year.

Based in Los Angeles, California. Hybrid, with flexibility. For the right builder, we're open to remote.