Founding AI-Native Product Engineer

Ellis, Inc.; Northern, New York (KY, NY); Hybrid; USD 180,000 - 240,000; Full time

Benefits offered by this job

Competitive equity

Comprehensive benefits package

Flexible PTO

Company-provided laptop

Hybrid work schedule

Opportunity to shape AI-native org

Job summary

Ellis, Inc. seeks an experienced engineer to establish its AI-native product engineering model, set standards, and own the harness that makes agent output trustworthy. You will ship more product surface area per engineer using Claude Code and agentic workflows.

You’ll own the growing feature surface and work directly with the Chief Product Officer and data infrastructure engineers to align product scope with the data layer contracts. This is a high-impact, founding-role within the team.

Qualifications

• 8+ years shipping product end-to-end with strong full-stack range.
• Experience building AI-native systems and agentic tooling.
• Proven judgment on what is ready to ship when an agent writes code.

Responsibilities

• Define Ellis's AI-native product engineering model and standards.
• Own growing feature surface including UI and agent-powered workflows.
• Collaborate with Chief Product Officer and data infra engineers.

Skills

TypeScript/React

Python

Claude Code

Agentic workflows

Tools

Claude Code

Cursor

Job description

Establish Ellis's AI-native product engineering model — the practices, standards, and infrastructure that define how we build product with Claude Code and agentic workflows — while owning the growing feature surface.

About Ellis

Ellis is building the unified data layer for private credit fund managers. We ingest, reconcile, and make sense of the financial data that fund CFOs and controllers live inside every day — NAV calculations, LP returns, reconciliation across GP records and fund administrators, SBIC compliance filings — and turn it into a trusted, queryable foundation for every decision the fund makes.

We're a seed-stage company with real customers, real data, and real financial stakes. Design partners and early clients depend on the accuracy of our platform for their fund reporting today. A silent data error costs us a customer permanently. That trust is the moat, and it's what makes this role matter.

About the role

Now we're making a deliberate bet on how we build from here: our product engineers will run AI agents in parallel, own the harness that makes agent output trustworthy, and ship more product surface area per engineer than a traditional full-stack team can.

We've studied how the fastest AI-native engineering teams operate. The bottleneck isn't typing — it's judgment, taste, and the ability to decide what "good enough to ship" means when an agent wrote the code.

This is the most important hire in our current plan.

You will establish our AI-native product engineering model — the practices, standards, and infrastructure that define how Ellis builds product features using Claude Code and agentic workflows. You're not inheriting a playbook. You are writing it. That means setting what skills get built first, what the prompt library looks like, how agent-generated diffs get reviewed, and what behavioral tests gate a deploy.

On the product side, you'll own the growing feature surface: Traceability UI, self-service column mapping, forecasting and scenario-planning modules. You'll work directly with the Chief Product Officer on scope and with our data infrastructure engineers at every place your work reaches the data layer's contracts.

Before applying, be honest with yourself about one thing: your energy should come from shipping, not from writing every line. Engineers who find the craft of reading and authoring code intrinsically satisfying will find this world less fun. Engineers who want to see features land, partners get value, and the product grow will find it more energizing than anything they've done before.

Feature factory and product ownership

• Surface area — Own the day-to-day execution of Ellis's growing feature set: new modules, new UI, new agent-powered workflows, built via Claude Code agents running against a well-built harness.
• AI-native development — Run 4-10 Claude Code agents in parallel across multiple workstreams. Context-switching is the skill. Shipping is the output.
• Partner-facing quality — You set the ship bar for agent-generated features. When a feature reaches a design partner, it's because you decided it was ready, not because it passed a linter.

Setting the operating model

• Skills and prompt library — Build the first version of Ellis's skills library, prompt library, and agent run patterns. These become the shared infrastructure every product engineer uses. You're building the factory floor, not just running one machine on it.
• Review standards — Define what "good enough to ship" means when an agent produced the code. Write the review checklist. Set the precedent that the next engineers inherit.
• Culture of paranoia — You assume the agent is wrong. You build the test that proves it. The behavioral test suite you establish here is what keeps the house from being a house of cards.
• Skill codification — When you find yourself prompting the same way across multiple tasks, you don't just keep doing it — you write the skill. The shared skills library grows because you use it hard and fill the gaps you find.
• Guardrail loops — When an agent produces a failure mode you didn't expect, you don't just fix the output. You close the loop with a lint rule, an eval case, or a prompt guardrail that catches it next time. You're building the institutional memory of how our agents fail.
• Eval contributions — You write eval definitions for the features you ship: not just behavioral tests, but golden-set evals that define what "good" looks like for agent output in your specific domain (React components, GraphQL mutations, data-adjacent UI logic).
• Human-in-the-loop design — For any agent workflow that surfaces financial data or drives user-facing decisions, you define the human review checkpoint. What does the agent handle autonomously? What does it flag for human sign-off? This is engineering judgment and product design at the same time.
• Agent run patterns — You document the prompting patterns and agent run sequences that work for your task types. The next engineer who joins ships faster because you wrote it down.
• Data contract discipline — Define, with our data infrastructure engineers, which parts of the data layer contract your team can consume and what the protocol is when a diff reaches toward financial calculation logic. This boundary exists for a reason — you keep it honest under shipping pressure.
• Product-engineering bridge — Work directly with the Chief Product Officer on feature scope. Translate fund manager workflows into agent-ready specs. Surface what the product can and can't do given the data contract.
• Harness evolution — As the platform engineer builds infrastructure underneath you, you feed back what's working and what isn't. The harness improves because you're using it hard.

What success looks like in your first 6-12 months

• The operating model is real — A new engineer joining after you can read the skills library, prompt library, and ship criteria and understand how Ellis builds product. The playbook exists because you wrote it.
• Feature throughput is measurably higher — Ellis ships more product surface area per sprint than it did before you arrived, and the quality holds.
• Partners trust the features you ship — Traceability UI, self-service column mapping, and forecasting modules are live with design partners and generating positive signal in commercial conversations.
• The data boundary holds — Not a single agent-generated diff has reached financial calculation logic without data engineering sign-off. The contract is enforced, not just documented.
• You've hired and leveled up — You've been involved in hiring the next AI-native product engineer and they're shipping against the model you built.

The ideal candidate

• Have 8+ years shipping product end-to-end with strong full-stack range — TypeScript/React on the frontend, fluent in Python or another server language on the backend.
• Have used Claude Code, Cursor, or equivalent agentic tooling on real production work, not experiments. Expect to be asked to walk us through a specific example of something you shipped this way.
• Are opinionated about what makes agent-generated code trustworthy — what review layers are necessary, what behavioral tests catch that unit tests miss, where human judgment is non-negotiable.
• Have a track record of owning surface area, not just contributing to it — you've been the person accountable for a product area shipping, not a member of a team that shipped it.
• Get energy from shipping, not from writing every line. This is non-negotiable and we will be direct about it in the interview process.

Nice to have

• Has built or maintained a skills/prompt library for an engineering team
• Has set standards for AI-generated code quality — review criteria, eval frameworks, ship checklists
• Fintech or regulated-industry context where correctness at the AI/data boundary matters
• Has hired or grown a product engineering function before

Location

This role is based in New York and will work from our Soho office 3-4 days a week.

• Competitive compensation with meaningful equity
• Comprehensive medical, dental, and vision coverage
• Flexible PTO
• Company-provided laptop
• Hybrid work environment with periodic team offsites
• Chance to define how an AI-native engineering org operates from the ground up