Rohit Kelapure · Cofounder. Product Manager and first FDE @ 8090 · Palo Alto
I sit with the people who know the exception paths, then build the agents, evals and review gates that run on them.
Recent builds
IC proof
Architecture-level work on production systems. Operating receipts on Claude (Code, API, MCP) — separate page.
Healthcare document pipeline on AWS: classification models, workflow rules, patient matching with partial identifiers, escalation for low-confidence cases. Multi-model fallback chain (Claude + vision preprocessing). What lands on the human queue at 8 a.m. matters more than aggregate accuracy.
Hard part: Confidence thresholds. Too low floods the queue; too high misses exceptions. We tune per document type and retrain when error patterns shift.
Public end-to-end PRD evaluation service. React frontend → Fastify gateway on Cloud Run → private Python judge runtime. Binary GO/REVISE/HOLD verdicts, deterministic readiness score, C1–C12 rubric criteria. Evidence quotes are checked against the source, and unverifiable citations fail closed.
Hard part: Making PASS/FAIL and fix plans trustworthy enough to feed downstream agents. Pinned judge bundles and model allowlists prevent drift.
View on GitHub →Extracting Medicare pricing and claims rules from legacy COBOL into English rules with source traceability (2026, ongoing). Claude mines the rules; a test corpus checks them against black-box pricer behavior.
Hard part: Models fail on legacy semantics. You don't rewrite until you can defend the rules in a format humans and agents can verify. A partial AST is not a migration plan.
View on GitHub →Enterprise AI doesn't fail because the model can't write another paragraph. It fails because the official process is not the real process.
The real process includes the fax that arrives sideways. The claim rule buried in a transmittal nobody indexed. The medical reviewer who knows exactly which sentence will trigger another review cycle. The salesperson who can configure a custom pack only because she remembers what the old system leaves out.
Interviews produce requirements. Watching people work produces the exception paths. The software has to survive both. That's why I work on-site before I write a line of intent.
"Fax is still an API in healthcare."
Field notes
At a national healthcare-equipment provider, we built document-intelligence and audit workflows around incoming faxes. The production system combines document models, workflow rules, patient matching, and escalation — not one model pretending it can solve every page.
The demo reads documents. Production reads documents that arrive sideways, half-cut, or with someone's coffee ring obscuring the patient ID. Confidence thresholds and fallback chains matter more than the model.
Discovery, production system design, healthcare domain
For a specialty-pharma medical-affairs workflow, we built a six-stage, human-controlled document pipeline with auditability and formal evaluation. Eighteen months in production: authoring time from 6–9 hours to 1.5, response time from 18 days to 4, MRC cycles from 3 to 1.
In regulated work, the review gate is the product. Skip it and you don't have a product — you have a liability.
Regulated AI systems, evaluation design, life sciences domain
We're extracting Medicare pricing and claims rules from legacy COBOL into English rules with source traceability. The first deliverable is not replacement code. It's a defensible map of business rules, dependencies, inputs, outputs, and exceptions.
You don't rewrite the code until you understand the code. There is no silver bullet here — you reverse-engineer the rules first or you ship bugs at scale.
Legacy modernization, code understanding, government systems
For a custom surgical-pack business, discovery ran for weeks across manufacturing, commercial operations, and IT. The PRD went through multiple versions before steering-team acceptance.
An agent cannot rescue you from an ambiguous product. It will implement the ambiguity faster and with more confidence. That's worse.
Product discovery, cross-functional alignment, enterprise software
What production changed my mind about
Better models make unclear requirements more expensive, not less. They produce more convincing wrong work, faster. Intent, examples, exclusions, and acceptance tests are now runtime inputs — not things you figure out later.
Healthcare AI taught me this — a confident wrong answer creates audit liability.
A PRD is not done because a room of humans nods at it. It's done when it's precise enough for agents to decompose, build, and test — and for an independent judge to reject the result when it misses the intent.
Watched agents faithfully build the wrong thing from ambiguous specs. More than once.
"Ninety percent automated" tells me nothing. What happens in the other ten percent? Who sees uncertainty? Who can override the system? What evidence do they get? What gets recorded? That's the architecture.
Built escalation paths for document-intelligence systems. The 10% is where the product lives.
Agent labor is not free just because it's fast. Model choice, reasoning effort, retries, review depth, context size — these are scheduling decisions now. Cost per accepted outcome matters more than tokens burned or lines generated.
Every writer agent I ship has a judge, a calibration report and a fail-closed default. The judge's false-GO rate comes first.
I run adversarial review on plans, PRDs, architecture, and business-case math. Two models disagreeing is information. Two models agreeing is not validation — it might just be two models confidently wrong.
Shipped regulated content where a single error triggers full re-review. Prevention beats rework.
My status updates lead with the risk. Customers can handle bad news. What they can't handle is discovering the team edited reality to keep a slide green.
Deploying at 33% quality against an 80% target is failure with extra steps. Define the eval before you ship.
Requirements link to designs. Designs link to work orders. Work orders link to code and validation. Break that chain and agents turn every upstream misunderstanding into technical debt at machine speed.
Built traceability into 8090's software factory. Without it, you're just generating debt faster.
The system
I run multiple Claude Code and Codex agents on one repo. Useful. But that's not the factory.
The factory is the system around them:
The maturity ladder is not autocomplete → more autocomplete. It's human inside every loop → human managing loops → agents operating within policy → humans accountable for the system.
Stop being the thing inside the loop. But don't remove responsibility from the loop.
The arc
At IBM, I learned to care about what happens inside a runtime: caching, contention, performance, failure, and production Java. 19 patent filings, including 10 grants.
At Pivotal, I learned that modernization is not primarily a code problem. Architecture, team structure, language, incentives, and delivery practice move together. Helped build the application-modernization practice from zero. Authored the AppTx Radar and modernization surgery patterns; presented at SpringOne and InfoQ.
At Google Cloud (2021–24) I ran application-modernization and database solutions, including early Gemini customer work. I left to build again.
At 8090, those threads collapsed into one job. Sit with the customer, shape the product, build the system, measure the failure, explain the economics, carry what we learn into the next version of the factory. Started in healthcare and life sciences; the same method now runs in commercial P&C underwriting and legal eDiscovery.
Context for model teams
Confidence calibration breaks on messy inputs. Fax pages arrive sideways, half-cut, coffee-stained. I tune thresholds per document type; low-confidence cases route to humans. The model's aggregate accuracy matters less than what lands on the review queue at 8 a.m.
Retrieval degrades over time. A code-index that worked three months ago misses files today because the codebase and agent tooling both evolved. Ranking requires continuous maintenance.
Models fail on legacy semantics. COBOL business rules don't parse until I verify extracted rules against black-box pricer behavior with a test corpus. A partial AST is not understanding.
Benchmark scores diverge from rejection rates. Medical reviewers know which sentence triggers another review cycle. The gap between what a model produces and what a domain expert accepts is where production fails.
I run multi-model adversarial review because no single model handles every domain. Deployment is where capability gaps surface.
Field notes from the software factory
I ran an AI DDD-analysis skill on five legacy codebases. A second critic changed 3 of 5 answers, and the real value was the hidden business rules, not the map.
Why AI hasn't diffused across the Fortune 100: wrong form factor, wrong use case, backward workflows, evals as theater.
Feathers' definition of legacy code, plus a 1M-token output window: generate characterization tests, lock the baseline, gate the rewrite.
Why 128K vs 1M of output is the real constraint when models rewrite legacy systems.
Browser clicks, then AppScript, then clasp: the agent upgraded its own approach while editing a PRD.
Archive: InfoQ · SpringOne / NFJS · cloud.rohitkelapure.com
I take on workflows whose exception paths live in people's heads — regulated content, legacy rules, intake that fails in public.
I also talk with Applied AI and Forward Deployed teams at frontier labs when the work is production systems with real liability.