AI Engineering
Ship Production AI Features, Not Demos
Fixed-scope projects that take AI from prototype to production. LLM integration, RAG pipelines, structured outputs, and the infrastructure to keep it all running.
Every pattern I bring has been tested with real users, real token budgets, and real error rates. Not adapted from blog posts. Not theoretical. Built and shipped.
The Problem
Your team built a working prototype. The demo looked great. Leadership is excited. And now it's been sitting in a branch for three months because nobody knows how to get it to production.
The gap between "it works in a notebook" and "it works in production" is where most AI projects die. Token costs spiral when you hit real traffic. Error handling doesn't exist because the prototype never needed it. There's no evaluation framework, so you can't tell if the model is actually improving or just different. The happy path works, but every edge case surfaces a new failure mode nobody anticipated.
This isn't a team problem. It's an experience problem. Production AI has a different set of constraints than traditional software, and most teams haven't shipped enough of it to have the patterns internalized.
Where AI projects stall
Most of the work is in the last three. That's what I do.
Project Types
Investment
AI Strategy & Roadmap
$3k–$5k
1–2 weeks
Before writing any code, figure out what's worth building. I evaluate your product, your data, and your team's capabilities to identify the AI features that will actually move the needle. You get a prioritized roadmap with honest assessments of complexity, cost, and risk.
- • Product & data landscape review
- • Prioritized feature roadmap
- • Build vs. buy recommendations
- • Cost projections and risk assessment
Feature Implementation
$8k–$20k
2–6 weeks
The core offering. I build and ship the AI feature end-to-end: architecture, implementation, error handling, cost controls, and evaluation. Your team gets a production feature they can maintain, not a black box they're afraid to touch.
- • Production-ready implementation
- • Error handling & fallback strategies
- • Cost monitoring & optimization
- • Team handoff with documentation
Prototype + Production Plan
$10k–$15k
3–4 weeks
For teams that need to validate an idea before committing to full implementation. I build a working prototype that proves the concept, then deliver a detailed production architecture so your team knows exactly how to take it the rest of the way.
- • Working prototype with real data
- • Feasibility & constraint analysis
- • Production architecture document
- • Implementation roadmap for your team
Not sure which fits? We'll figure it out on the discovery call.
What I Build
Capabilities
AI Features
- LLM integration
Adding language model capabilities to existing products. Prompt design, response parsing, streaming, and graceful degradation when the model doesn't cooperate.
- RAG pipelines
Retrieval-augmented generation that actually works. Document ingestion, chunking strategies, embedding selection, and retrieval that returns relevant results, not just similar ones.
- Structured outputs & tool use
Getting reliable, typed responses from language models. JSON schemas, function calling, validation layers, and retry logic for when the model returns something unexpected.
- Agent architectures
Multi-step AI workflows that coordinate tools, manage state, and handle the failure modes that only show up at scale. Built with clear boundaries so your team can reason about what the agent is doing.
Production Infrastructure
- Error handling & fallbacks
LLMs fail in ways traditional software doesn't. Rate limits, timeouts, malformed responses, content policy violations. Every failure mode gets a recovery path.
- Cost monitoring & optimization
Token usage tracking, per-feature cost attribution, caching strategies, and model selection logic. The difference between a feature that costs $50/month and one that costs $5,000/month is often a few architectural decisions.
- Evaluation frameworks
You can't improve what you can't measure. Automated evals, regression detection, and quality scoring so you know when a model update or prompt change actually made things better.
- Observability & logging
Structured logging for LLM interactions, latency tracking, and dashboards that show you what's happening in production. When something goes wrong, you'll know exactly where to look.
How It Works
Discovery
A 30-minute call to understand what you're building, where you're stuck, and what success looks like. If it's not a good fit, I'll tell you. If it is, I'll scope the project and send a proposal within 48 hours.
Architecture
Before writing implementation code, I map the system: data flow, model selection, error boundaries, cost projections, and integration points with your existing stack. You review and approve the architecture before I start building.
Implementation
I build in your codebase, following your conventions. Regular check-ins, PRs against your repo, and no surprises. If I hit a constraint that changes the plan, you'll know immediately, not at the end of the project.
Handoff
Your team owns it from day one. Architecture docs, inline documentation, a walkthrough session with your engineers, and a clear maintenance guide. I build things your team can understand, extend, and debug without me.
Who This Is For
Good fit
- Teams ready to ship AI features, not just explore what's possible
- Products where AI is a differentiator, not a checkbox on a feature list
- Engineering orgs that want it done right the first time instead of rebuilding later
- Teams that built a prototype but can't get it to production
Not a fit
- Prompt engineering as a service. If the only problem is the prompt, you don't need me.
- "Add AI to everything" consulting. I'll tell you where AI helps and where it doesn't.
- Projects without clear user value. If you can't explain who benefits and how, we're not ready to build.
- Research projects or open-ended exploration. I build things that ship.
What Clients Say
"He quickly understood where we were with AI tooling and gave us immediately actionable advice, not generic frameworks. He identified gaps we hadn't considered, walked us through how he architects agent loops in production, and helped us think through our product-level agent strategy without over-engineering it."
Frequently Asked Questions
What stack do you work with?
My deepest expertise is Rails and Ruby, but AI engineering projects work across stacks. The patterns for LLM integration, RAG, structured outputs, and production infrastructure are largely language-agnostic. I've shipped AI features in Rails, Node, and Python environments. If your stack is unusual, we'll figure out fit on the discovery call.
Do you stay on after the project?
The goal is always a clean handoff. Your team should be able to maintain, extend, and debug the feature without me. That said, some clients keep me on retainer for ongoing advisory as they build out more AI capabilities. We can discuss that if it makes sense for you.
What if we're not sure what to build?
That's what the AI Strategy & Roadmap engagement is for. I'll evaluate what's possible given your product, your data, and your team's constraints, then give you a prioritized list of what's worth building and what isn't. If you're not ready to build, I'd rather help you figure that out than build the wrong thing.
How is this different from hiring an AI consultant?
Most AI consultants advise. I build. The deliverable isn't a slide deck or a strategy document (unless that's what you need). It's working code in your repo, merged into your main branch, running in production. I also still ship AI features daily as a full-time engineer at August Health, so the patterns I bring are current, not from a project I did two years ago.
What does the timeline look like?
Most projects start within 1-2 weeks of signing. I limit active engagements to 1-2 at a time, so I can give your project the attention it needs. Timelines are scoped to the project type: strategy work takes 1-2 weeks, feature implementation takes 2-6 weeks, and prototype projects take 3-4 weeks.
Let's Talk About Your Project
Book a free 30-minute discovery call. Tell me what you're building and where you're stuck. I'll be honest about whether I can help and which project type makes sense.