Production-grade RAG for PDFs, scans and email containers in days — and a team that ships twice a week without breaking the eval.
This is AIESCU's operator brief: who builds (Teo Deleanu, through AIESCU LLC), how we build, the proof, and how an engagement runs — a free scoping week, then a flat $20k 4-week build sprint and a handover you own. The doc-intel-platform demo in §03 is the kind of MVP I deliver. §09 has the engagement shape, commercial terms, and three ways to continue (or walk away clean) after.
This artifact is allowed to be honest about what I haven't shipped — without being allowed to bluff what I have.
Scaling document ingestion
The hardest problems on a doc-intelligence roadmap are document problems. Multi-thousand-page PDFs. Scanned images. Email containers. Office files. Archives. Each format has its own failure mode — OCR misroutes, embeddings drift between model versions, queue retries silently double-charge a provider, an “idempotent” job races itself on a redeploy.
These problems need an engineer who has personally shipped these systems — not a doc-AI manager from a distance. Someone who can write the post-mortem AND set the technical bar your team keeps after the handover.
- ·OCR routing on scanned multi-thousand-page packages
- ·Format detection (mixed text / image / embedded fonts)
- ·Splitting + chunking under token budgets
- ·Queue retry storms after a provider 429
- ·Idempotency races on redeploys
- ·Eval regressions silently shipped to prod
- ·OCR fallback policy + per-stage observability
- ·Multi-provider router with graceful degradation
- ·Cassette-everything CI so eval gates can fail loud
- ·DLQ + replay tooling for ops to recover docs
- ·SLOs the team actually believes in
- ·Post-mortems before incidents repeat
Thesis
Player-coach by default. I still write specs and read every PR. I just don't type the keys — Claude Code does. In my peak week, 117 PRs landed across a production AI platform, all AI-generated, all reviewed by me. That's how I scale a 5–10 person team without becoming the bottleneck.
Spec-first, eval-as-CI. Every system I ship starts with a spec that goes through 4–5 review rounds before any code (sample spec). Then eval gates run on every PR with the delta posted as a comment (eval CI workflow) — if recall@k drops, the merge button is gone.
Subagent-driven implementation. I split each project into landing lanes — disjoint file ownership boundaries that let parallel implementer agents (or humans) land code without merge conflicts, the way runways at an airport keep planes from colliding. Two-stage review per chunk: spec compliance, then code quality. That's the engineering culture every sprint runs on.
doc-intel-platform — I built the MVP this week
To make this brief honest, I sat down and built a 15-chunk MVP of a doc-intelligence system the way one should be built. Spec-first, subagent-driven, eval-as-CI, two-stage review per chunk. 3 calendar days from empty repo to a 458-pytest / 48-vitest / 3-Playwright-spec green build with multi-provider LLM routing, swappable index backends, OCR fallback, OTel + Prometheus + structlog, and a live /demo flow that streams stage events into the browser via SSE.
The repo is real. github.com/aiescu/doc-intel-platform. Every chunk has its own PR, its own review pass, and a runnable acceptance gate.
The “without me” panel is not snark. It's the literal sequence of incidents I've watched ship five times across five different teams. The “with me” panel is the sequence of chunks actually merged on github.com/aiescu/doc-intel-platform.
Sample portfolio — production systems, with the receipts
The case studies below are ordered by doc-intelligence relevance. The 2026 production AI contract entry is current, founder-direct, full-time. The 2025 entries are AIESCU LLC customer engagements — hourly-billed, founder-direct. The 2024 entries are from a 9-year platform tenure on an internal IoT analytics + agent stack.
AI capabilities · evidence matrix
AI engineering theme by theme. Each row is a capability; the receipts are the repos where I shipped it. Expand for the per-repo cut.
- ·Claude Opus 4.8 / Sonnet 4.6
- ·OpenAI GPT-5.5 / GPT-5.4 mini
- ·Gemini 2.5→3.5 · Vertex AI
- ·AWS Bedrock · Titan V2 / Cohere Embed v4
- ·LiteLLM — unified gateway + per-task fallback
- ·LangGraph · LangChain 1.x
- ·MCP tool servers (FastMCP)
- ·pgvector · OpenSearch hybrid · RRF k=60
- ·text-embedding-3-large (3072d)
- ·eval-as-CI — faithfulness · citation · recall@k
- ·Python · TypeScript · Go · Rust
- ·FastAPI · Celery · Temporal · ARQ
- ·PostgreSQL · Redis · Elasticsearch
- ·Snowflake · Databricks · Neo4j
- ·AWS · EKS / ECS · ArgoCD GitOps
- ·OpenTelemetry · Prometheus · Langfuse
- ·Datadog · Grafana LGTM stack
- ·Docker · Terragrunt
Full per-library index with scale numbers in §13 (unlocks with a private access link).
What to check before you hand over an AI build — with the evidence
What should be true of whoever builds your production AI. Here's that checklist, with the receipt for each row.
How I work
20% coach / 80% player when your team needs me writing specs and shipping code alongside them. 80% coach / 20% player when your team is humming and needs me to set the bar, review, and clear blockers. We pick the ratio explicitly in the scoping week. Founders rarely have this conversation in writing — it's usually where an engagement gets miscast.
Every non-trivial spec gets 4–5 review passes before code. Catches the ~50 issues a half-baked implementation would surface in incidents.
Twice-a-week to main, behind eval-as-CI gates. Cadence is preserved by tooling, not by heroics.
Every line since 2025 is Claude Code generated. Peak week: 117 PRs. The discipline is in spec quality and review depth, not keystrokes.
Per chunk: spec-compliance reviewer first, code-quality reviewer second. Implementer agent fixes between rounds. Two-stage is non-negotiable.
Eval-as-CI + Playwright e2e + pytest + vitest + ruff + pyright. PR is red until all green. Then still red until reviewed.
Codex for fast, scoped iteration. Claude Code for spec-driven multi-chunk work. Both running in subagent mode against the same spec — different surfaces, same review discipline.
I manage AI agents the way I'd manage humans — except they don't burn out. A team of one delivers what a 5-person team would, because the bottleneck is spec quality and review depth, not keystrokes.
Versioned skill library loaded by both CLIs before tool calls. ADOPT / FORK / BUILD governance. Semver pinning surfaces stale deps in CI. Customer-facing vs team-internal segregation.
I split a project into disjoint 'landing lanes' — non-colliding file-ownership boundaries — the way runways at an airport keep planes from colliding. Parallel agents (or humans) land code in their own lane without merge conflicts. doc-intel-platform was 14 chunks across 5 lanes (ingest · index · retrieve · observe · eval) — visible on the landing-page architecture diagram.
LLMs work fast against a monolith — one codebase, one context, fewer boundaries to reason about. Humans scale on microservices — clear team boundaries, independent deploys. Both shapes carry overhead. The art is picking the architecture that lets a small fleet of LLMs work fast without forcing humans into a topology they can't orchestrate — pick wrong and you lose the velocity you're paying for.
My virtual office runs 24/7: async-first, Looms instead of standups, customer calls recorded with consent, every decision documented. The discipline LLMs need to ship code IS the discipline that makes async work for humans — and institutional knowledge survives turnover that way.
How to engage — free scoping week, then a 4-week build sprint
Remote, ET-timezone delivery via AIESCU LLC. A free 30-minute scoping call, a free scoping week, then a flat $20k 4-week build sprint and a handover. You keep the code, ADRs, spec, eval suite and skills — no lock-in, no retainer. Larger scopes get a fixed multi-sprint quote.
The differentiator: customer-call recordings with consent (Granola / Fireflies / Otter) become the source of truth for the spec. Founders rarely get a documented research trail of their own customers' pain — the scoping week produces one.
1–2 days/week at the market day rate for senior fractional engagements, ET hours, quarterly on-site visit. Continuity on the spec without a full-time hire.
Keep building against the spec with another fixed-fee sprint, or a fixed multi-sprint quote for a larger scope. No retainer, no headcount commitment.
You keep the code, the ADRs, the spec, the eval suite, and the skills. I get a paid sprint and a real reference. Both sides clean.
Risks, lessons, open questions
Named risks, decisions I've walked back, and what's still open. The conversation parts at the bottom.
(a) Eval corpus availability — if no labeled customer corpus exists, eval-as-CI degrades to synthetic. Mitigation: budget corpus curation into the spec. (b) OCR vendor lock-in — if the current stack is single-provider, fallback policy is fragile. Mitigation: spec the abstraction in a scoping-week ADR.
(1) On the production DeFi platform — initially pushed Celery + RedBeat for the embedding pipeline; switched to RabbitMQ + bounded concurrency after 3 weeks of retry-storm pain on the 429 boundary. The ADR for the switch is in the repo. (2) On FundAtlas — argued for Temporal from day 1, was overruled (Celery first). Came back 6 months later with the 2000-pending-activity ceiling as evidence; the migration shipped. Lesson: bring the failure-mode receipts, not the framework opinion. (3) On a 2024 IoT agent stack — built a 200-tool MCP server, hit context-window ceilings on Claude. Replaced with a single generic-tool + 9k-token catalog. Lost a month.
(1) Retrieval quality over model size — chunking, hybrid search (RRF) and a reranker move recall@k far more than a bigger model; most 'second brains' fail on retrieval, not generation. (2) Capture at the source — the bottleneck is ingestion, not Q&A; auto-ingest from where work already happens (email, Slack, docs) instead of asking people to file things. (3) Agentic, not just lookup — it should draft the reply and take the next step via MCP tools, not only answer. (4) Provenance + freshness on every answer, and (5) evals as a first-class loop so retrieval regressions are caught like bugs. The first generation was a better search box; the next is an agent that reads your context and does the next step — and the hard part is trustworthy retrieval, not the model.
A real problem, access to (or a sample of) your data, and the free scoping call. During the engagement: a weekly founder check-in (recorded), and comfort with 'spec-first' meaning the scoping week settles the spec before any build code. Read access to the customer-success Slack — engineering needs to see customer pain in raw form, not filtered through PM.
(a) Whether AI-coded shipping (subagent-driven, 117 PRs/week) scales to a 10-person team or breaks at 5. (b) The right ratio of skills-library investment vs. just-in-time agent prompts as Claude/Gemini context windows grow. (c) Where MCP tool servers stop being the right primitive and direct-API calls win again. These are real open questions — happy to think out loud about them on the call.