Production-grade RAG for PDFs, scans and email containers in days — and a team that ships twice a week without breaking the eval.
This brief is what comes out of a paid 4-week Discovery & Architecture Sprint — recorded customer research, ADRs, a 14-chunk implementation spec, and chunks 1–2 shipped as living proof. The doc-intel-platform demo in §03 is the kind of week-4 MVP I deliver. §09 has the sprint 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.
The team needs a senior 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 the next five hires will measure themselves against.
- ·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 I'd bring on day one.
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).
Team requirements — your filter, my evidence
Your hiring brief lists what must be true for the candidate. Here's that filter, with the receipt for each row.
How I work
20% coach / 80% player when the team needs me writing specs and shipping code alongside them. 80% coach / 20% player when the team is humming and needs me to set the bar, run interviews, clear blockers, and own the roadmap. We pick the ratio explicitly in Week 1 and re-calibrate every quarter. Founders rarely have this conversation in writing — it's usually where the role 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 hiring me for.
The 'in-office' demand is usually a culture artifact, not a productivity one. 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. Seats in chairs don't.
How to engage — paid 4-week Discovery & Architecture Sprint
Full-time in-office in Miami / NYC / SF doesn't map to remote, ET-timezone delivery via AIESCU LLC. A paid 4-week Discovery & Architecture Sprint does. It produces the work the new Head of Engineering would have to do in their first month anyway — and you keep all of it whether or not anything continues after.
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 — this sprint 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 the in-office full-time shape.
Keep delivering chunks against the spec at the market day rate. Scales up or down with appetite; no headcount commitment.
You keep the recorded research, the spec, the 2 shipped chunks, the runbook, the hiring rubric. I get a paid month and a real reference. Both sides clean.
First 90 days — plan, risks, open questions
A 90-day plan with named risks. The conversation parts at the bottom.
(1) eval-as-CI delta gate live on every PR, blocking on faithfulness / citation / recall@k regressions. (2) OTel + Prometheus dashboards on doc-pipeline stages (extract · chunk · embed · index · retrieve · answer). (3) One on-call rotation tested via game-day with a simulated provider 429 cascade. (4) First written ADR cycle on the largest hidden-debt decision (usually OCR routing or chunking).
(1) Two senior eng offers out by day 45 (sourcing from my AIESCU LLC network + production-AI contacts). (2) Multi-provider LLMRouter w/ per-task fallback chain shipped behind eval gates. (3) DLQ + replay tooling for ops to recover stuck docs. (4) Incident post-mortem template adopted; first incident becomes a published ADR or runbook excerpt within 5 business days. (5) Hiring rubric written, calibrated, and used for both senior offers.
(1) Twice-a-week to main, eval-gated; cadence preserved by tooling not heroics. (2) Two senior hires onboarded with first PRs landed. (3) 90-day-review deck for the board: SLOs hit, eval delta trend, hire ramp, what's deferred and why. (4) Quarterly OKR cycle started; engineering OKRs tied to a customer outcome, not a system metric.
(a) Eval corpus availability — if no labeled customer corpus exists, eval-as-CI degrades to synthetic. Mitigation: 2 weeks of corpus curation in Days 1–14 budget. (b) OCR vendor lock-in — if current stack is single-provider, fallback policy is fragile. Mitigation: spec the abstraction in week-1 ADR. (c) Existing team morale — bringing in a senior hire above current eng leads can backfire. Mitigation: 1:1s with all engineers in week-1, no org changes for 30 days. (d) On-call gaps — small team + new pipeline = burnout risk. Mitigation: rotation w/ explicit comp, 5 incidents max before I'm forced into the rotation myself. (e) Hiring funnel ramp — 45-day offer timeline assumes a warm network. Mitigation: 3 sourcing channels parallel from day 1, monthly bar-recalibration.
(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.
Comfortable with startup intensity for the first 6 months. After that, the team's cadence depends on tooling (eval-as-CI, subagent dev, ADR culture) preventing heroics from becoming structural. I won't ship a 'work harder' culture — I'll ship the tooling that lets a 5-person team keep up with a 15-person roadmap.
Founder access weekly (45 min, recorded). Authority to set the technical bar in interviews — including the right to no-hire a candidate the founders like. Budget for two senior hires in the first 90 days at competitive senior-eng comp. Comfort with 'spec-first' meaning a week of spec before any code on the hardest problems. 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.