AI-Native Product Engineer

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

Benefits offered by this job

Equity

Medical/Dental/Vision

Flexible PTO

Laptop provided

Hybrid work with offsites

AI-native product org

Job summary

Ellis, Inc. is building a unified data layer for private credit fund managers. We empower the team to own features end-to-end, from scope with the Chief Product Officer to running Claude Code agents and writing the behavioral tests that gate deployments.

This is a high-ownership generalist role requiring frontend (React/TypeScript) and backend (Python) skills, with a strong emphasis on parallel development and trustworthy outputs.

Qualifications

• 4+ years of full-stack engineering experience with customer-facing product surfaces.
• Strong frontend taste: React/TypeScript.
• Experience with AI agents and agentic tooling.
• Experience shipping features end-to-end from scope to deployment.

Responsibilities

• Own product surface area — build modules, UI components, and agent-powered workflows.
• Run multiple Claude Code agents in parallel across workstreams and manage context.
• Write behavioral tests and gate deployments for reliability.
• Collaborate with the Chief Product Officer on scope and expand the codebase.

Job description

Own features end-to-end against a purpose-built agent harness — from scope with the Chief Product Officer, to running Claude Code agents, to the behavioral tests that gate your own deploys — and double Ellis's parallel feature throughput.

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

We're a small team moving fast, and we've made a deliberate choice about how we build: our product engineers run AI agents in parallel against a purpose-built harness, ship more surface area than a traditional team could, and own the judgment calls that make agent output trustworthy.

By the time you join, the harness will be in place and the skills library will be growing. The behavioral test suite will be running. The operating model will be proven. Your job is to double our parallel feature throughput.

You'll work alongside our lead product engineer and report into that role, expanding Ellis's product surface area. You'll own features end-to-end — from collaborating with the Chief Product Officer on scope, to running Claude Code agents against the codebase, to writing the behavioral tests that gate your own deploys.

This is a role for a high-ownership generalist who finds multi-agent parallel development energizing. You're comfortable across the stack — React/TypeScript on the frontend, Python on the backend — and you use Claude Code as your primary development tool, not a supplement to it.

• Own product surface area — Build new modules, UI components, and agent-powered workflows using Claude Code agents running against the skills and prompt library our lead engineer has established. You don't just write tickets — you own features from spec to ship.
• Agent-driven development — Run multiple agents in parallel across workstreams. Manage context, review diffs with a paranoid eye, and make the judgment calls that determine what ships and what gets reworked.
• Full-stack range — Move across the stack as the product requires. Strong frontend taste is essential: our partners interact with dashboards, scenario planners, and reporting surfaces that need to feel right. Backend work is frequent; don't expect to stay in one layer.

Quality and testing

• Behavioral tests first — You don't ship without one. For every feature you touch, you own writing the test that covers the failure mode you're most worried about. The agent wrote the code; you proved it works.
• Culture of paranoia — You assume the agent made a mistake. You find it before it ships. That mindset is not optional here — it's how the whole model stays trustworthy.
• Regression ownership — When a behavioral test you wrote catches a future regression, that's a win. When it doesn't catch something it should have, you own the gap and close it.

Cross-team collaboration

• Data layer discipline — You understand where the data infrastructure boundary sits and you stay on the right side of it. When you need something from the data layer, you work with the data engineering team — you don't reach across the boundary unilaterally.
• Partner context — You build features for fund CFOs and controllers, not generic SaaS users. Within 90 days you should be able to read a fund's NAV reconciliation and know what looks normal versus what looks weird.
• Harness contribution — The skills library and eval suite improve because you're using them hard and feeding back what's working. You're not just a consumer of the platform infrastructure — you help make it better.

What success looks like in your first 6-12 months

• Features ship on your name — Multiple product modules are in production with design partners, and you're the engineer who owned them from scope to deploy.
• Behavioral test suite grows with you — Every feature you shipped has a corresponding behavioral test. The coverage doesn't degrade as the surface area expands.
• The data boundary has never been crossed — Not one agent-generated diff has reached financial calculation logic without data engineering review. You've kept the contract clean even under pressure to move fast.
• Partners notice the product improving — Design partners reference features you built in commercial conversations. The product is getting better in ways they can feel.
• You've leveled up the harness — At least one skill or prompt in the shared library exists because you identified a gap and filled it.

The ideal candidate

• Have 4+ years of full-stack engineering experience with strong frontend taste — you've shipped customer-facing product surfaces that users actually enjoyed using.
• Have used Claude Code, Cursor, or equivalent agentic tooling in real work — not just familiarity, actual shipped output you can walk us through.
• Are a high-ownership generalist — you pick up unfamiliar parts of the codebase and own them; you don't wait to be told what's next.
• Are paranoid by disposition — you assume the agent made a mistake somewhere, and you find it before it ships.
• Move fast without losing the thread — you can manage multiple agent workstreams in parallel without losing context on what each one is doing and why.

Nice to have

• Depth in TypeScript/React at the level of building real product features, not just component libraries
• Familiarity with GraphQL (we use Strawberry + graphql-request + GraphQL Codegen)
• Experience at a small team (under 15 people) where ownership was broad and handoffs were minimal
• Fintech or data-intensive product background

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 build and shape an AI-native product engineering org from the earliest days