AI Product Engineer

HireArchi; Metro Manila; Remote; PHP 1,407,000 - 1,759,000; Full time

Job summary

HireArchi is seeking an engineer who thrives on end-to-end feature ownership in an AI-assisted environment. You will design, implement, test, and ship features using Claude Code and other agents across .NET/C#, FastAPI, React, and PostgreSQL.

You will read every line the AI produces, manage several agents in parallel, and ensure state and scope stay aligned. This role emphasizes taste, velocity, and accountability in delivering non-trivial software with AI in the loop.

Qualifications

• Daily, fluent use of agentic coding tools (Claude Code, Cursor, Codex or similar).
• Ability to run multiple AI agents across separate work streams and deliver shipped work from each.
• Solid programming fundamentals in at least one of C#, TypeScript/JavaScript, or Python with understanding of HTTP APIs, relational databases, and async patterns.
• Strong product sense: ask three questions to clarify half-formed requirements and ship what users want.
• Ownership: finish features with tests, docs, and no dangling threads.
• Ship quality AI output with traces, evals, and guardrails to protect customers.

Responsibilities

• Take a rough idea to shipped feature end-to-end using agent-driven workflow.
• Read and validate every line produced by the AI before shipping.
• Manage multiple agents across several streams and keep them aligned and in sync.
• Ship services in .NET 10 LTS / C# (ASP.NET Core, Minimal APIs, background workers).
• Build Python services with FastAPI for agent execution engine and tooling.
• Design and evolve data models in PostgreSQL: schema, migrations, indexes, query performance.
• Build React 19 interfaces for admin consoles, data grids, forms, and chat UIs.
• Implement streaming chat, live updates, and integrate with LLM providers via tool calls and MCP servers.
• Write tests, docs, and ensure the loop is closed across services.
• Ship via Docker and GitHub Actions to cloud infrastructure.

Skills

Agentic coding

Parallel agents

Programming fundamentals

Product sense

Ownership & async

AI output quality

Tools

Claude Code

Cursor

Codex

LLM tooling

Job description

Working Schedule: Monday – Friday, 8am – 5pm Mountain Standard Time

Work Arrangement: Fully Remote

Salary: 2,000 - 2,500 USD

Employer: AI company located in Phoenix, Arizona

The Role

This is a new kind of engineering role. You won't be a code monkey wired into a backlog. You'll own features end-to-end using Claude Code and other coding agents: design, implementation, testing, shipping. You direct the AI, you read every line it produces, and you ship the finished thing.

You'll work across the platform: Threo (the client workspace), Wingtip (agentic execution from plain English requests), Pylon (agent creation and runtime), and Canopy (the control plane for every client tenant).

Our stack spans .NET/C# and FastAPI (Python) on the backend, React on the frontend, and PostgreSQL for data. You don't need to know it all on day one — you need to ramp fast with coding agents and ship in stacks you haven't touched before. We hire for taste and velocity.

What You'll Do

• Take a problem from rough idea to shipped feature: design, build, test, deploy, working from specs and repo-level agent instructions you and your agents both use. No handoffs for "the real implementation".

• Read every line the AI produces. You're accountable for what ships, not the model.

• Operate two, three, or more AI agents at once across separate work streams (new features, bug fixes, refactors), keeping each in its own sandbox or work tree and shipping from all of them the same day without losing state or scope.

• Ship services in .NET 10 LTS / C# (ASP.NET Core, Minimal APIs, background workers).

• Build and extend Python services using FastAPI for our agent execution engine and adjacent tooling.

• Design and evolve data models in PostgreSQL: schema, migrations, indexes, query performance.

• Build React 19 interfaces with the stable React Compiler — admin consoles, data grids, forms, and chat UIs.

• Implement streaming chat and live updates, and integrate with LLM providers via tool calling and MCP servers, structured outputs, retries, and fallbacks.

• Write tests, write docs, close the loop, and debug across services and stacks — the AI helps, but it doesn't excuse you from understanding the system. The bar is "that's done," not "the happy path works.".

• Ship via Docker and GitHub Actions to our cloud infrastructure.

What We're Looking For

We hire on AI fluency, judgment, and velocity, not years of experience. If you live in Claude Code (or Cursor, or Codex) and ship real software with it, we want to talk.

Must Have

• Daily, fluent use of agentic coding tools (Claude Code, Cursor, Codex, or similar). We care that you can direct an agent through a non-trivial feature without losing the plot — not which tool you use — and that your first instinct is to design with AI in the loop.

• Parallel agent management. You can run multiple agents at once across separate work streams (features, bug fixes, refactors) and deliver shipped work from each.

• Solid programming fundamentals. You can read and reason about code in at least one of: C#, TypeScript/JavaScript, or Python. You understand HTTP APIs, relational databases, and basic async patterns. You can debug what you didn't write.

• Product sense. You can look at a half-formed requirement, ask the right three questions, then ship something the user actually wants.

• Ownership and clear async communication. When you pick up a feature, you finish it: tests, docs, no dangling threads, no partial solves left for someone else.

• Quality checks on AI output. You ship the full loop — traces, trajectory-level evals, and guardrails against prompt injection — and can show a non-deterministic feature is safe in front of paying customers.

Nice to Have

• Streaming systems (WebSockets, SignalR, or similar).

• LLM integration work: tool calling and MCP servers, streaming, and retrieval or context engineering.

• LLM cost and latency optimization: caching, model routing, token budgets.

• Multi-tenant SaaS architecture.

• Familiarity with MSP/PSA ecosystems (ConnectWise, Autotask, Datto RMM, etc.).