8090

Re-introducing 8090... Two ways to work with us: → [BUILD] Software Factory: the platform for consulting and technology businesses building software with AI agents. The documentation stays alive because the system keeps it alive (no one ever updates the PRD on their own). → [BUY] 8090 Enterprise: AI-native custom software we design, build, and host tailored to your exact business needs. Give us a problem and we go execute. What part of your current SDLC is the most overdue for a rebuild? 8090.ai/?utm_source=x&…

Introducing MCP Server Integrations in Software Factory. Connect external MCP servers from Settings → Connections. Agents can then discover and call tools from those services. Includes server cards, OAuth connect/disconnect, and detail views.

@theshaneemoret Consistency, by a mile. Models read COBOL fine. The hard part was getting the same rules back every time we reran the pipeline, plus citations on each one so CMS experts could grade what came out. That took far longer than the reading did.

@8090_Factory What was the hardest part of the process?

The United States Medicare claims system: 18 million lines of Assembly and COBOL, 50 years of policy logic. Working with CMS, our Enterprise team read the code and documented 100,000+ business rules in plain English using Software Factory, each traced to its exact source line. The people who own Medicare policy can now read how their systems behave. Full story in the thread.

@MMoreMillions @chamath Our first complete generation pass across the four claims systems took 40 days. Before that it was smaller single-system batches, and the expert review with CMS ran alongside the whole way.

@chamath How long does a project like this take?

Here is the first case study of what 8090 can do. Working with CMS, our Enterprise team decoded a 50yr, 18M repo of COBOL and Assembly that governs billions in healthcare payments. We documented 100,000+ business rules in plain English using Software Factory, each traced to its exact source line. The people who own Medicare policy can now read how their systems behave and change as they see fit. Full story in the thread below. We can do this for any large enterprise who have big, legacy codebases.

@getprasannav @chamath By putting the output in front of the people who know the system. CMS experts graded randomly sampled rules, sometimes spending an hour on one, and a few of them were there when the original COBOL was written. Every rule also cites its source lines.

@chamath This is huge. Love this. How did you eval the output? 100,000 plus business rules is crazy. 🫡

@Dansfera @chamath You're right, and that's how the pipeline is built. Most of it is checking, not generating: deterministic validation next to the LLM passes, evidence attached to every rule, and CMS experts grading random samples against decades of running the thing.

@chamath the english translation is the easy 80 percent. the part that governs billions is proving the plain-english rules are behaviorally identical to the assembly in every edge case. thats an eval and diffing problem, not a reading problem

@zazmic_inc @chamath That's the right bar. Nothing rests on one model pass here: repeated LLM and deterministic checks, line-level citations on every rule, and CMS reviewers grading random samples. The citations exist exactly so you can check a rule against the COBOL it came from.

@chamath Done this on smaller legacy systems before, and what I'd be looking at is proving each one of them actually does what cobol did, not reading the rules into English.

@tinhtrann @chamath Edge cases were the whole worry. It's why the pipeline runs many passes with deterministic checks instead of one generation, and why every rule keeps a line citation so you can walk it back to the code. CMS experts graded samples, sometimes an hour on a single rule.

@chamath lotta gov legacy systems need this kind of lift. curious how it handles edge cases in the business rules though, those are always the killer.

@elsalomebarojas @chamath Full story is here: 8090.ai/customer-stori…. And thanks for the flag, it should have been easier to find in the thread.

@chamath where is the full story? I don't see it in this thread.

@justinwitz @chamath That's right, the agents did the reading, and it sounds like you know this problem well. The team built what ran around them: the deterministic checks, the citations on every rule, and the review loop where CMS experts graded sampled output.

I think you mean, AI read the code. Your team definitely didn't read 18 million lines of code. I've built enterprise grade platforms for dozens in the Fortune 500 and NASA / Space Force for our ICBM's converting COBOL to modern programming languages and documenting the process. You're doing good work.

@Invisiblami @chamath You'd want to read it before you rewrite it. This system pays out billions, so CMS first needs a verified map of what it actually does. That's what the 100,000+ rules are, each cited to source lines. Any rewrite can now be tested against that map.

@chamath @8090_Factory now, what's holding you to get it rewritten by Claude/ cursor in a modern language ( in hrs. ? )

@ogsada @chamath Partly fair, models do the reading here too. Budget helps, but the hard part was tens of gigabytes of docs plus the full source, getting reproducible output across runs, and a line-level audit trail CMS experts could actually grade. That's what took the engineering

@chamath I can do the same with cursor if I had the same budget, what's so great about 8090?

@DNormandin1234 @chamath The difference is everything after generation. A raw pass at this scale overflows the context window, returns different rules every run, and leaves nothing to audit. Each of the 100,000+ rules here traces to exact source lines and comes out the same on regeneration.

@chamath what's the difference between software factory and just pointing GPT 5.6 Sol at the codebase and having it come up with business rules in a markdown file?

@ClaudeVanCode @chamath Agreed that reading the code is the standard. The catch is that 18M lines is more than anyone can hold in their head. So every extracted rule keeps a citation to its source lines, and you read the plain English with the pointer back to the code right there.

@chamath I'm sure they can read it, the question is whether they can understand it any better than they would by just inspecting the code.

@veeerunner Edge cases were the whole worry. It's why the pipeline runs many passes with deterministic checks instead of one generation, and why every rule keeps a line citation so you can walk it back to the code. CMS experts graded samples, sometimes an hour on a single rule.

@8090_Factory Claude can do that. Why do I need a software factory for that???

@beratcelik0 @chamath We worked from the production codebase, and every rule cites the exact lines it came from, so it reflects what the code does today rather than what the manuals say. Then CMS experts who've run these systems for decades checked sampled rules against that.

@Jonathan_Blow @chamath We didn't trust any single pass. The pipeline ran repeated LLM and deterministic checks, every rule carries a citation to the exact source lines, and CMS's own experts, some with 20+ years on these systems, graded random samples of what came out.

@chamath How do you know that this output is accurate?

If your organization runs on a complex system that's holding the business back, that's exactly the problem we like solving. More on our work with CMS: bit.ly/4f9E4y0

The proof point behind the market math: bit.ly/8090-fs-proof

Chamath broke down the $5T software market on TWiST: $4T of it goes to maintenance and services, not the software itself. A financial services client was paying $2M a year to an outside vendor for a process that kept falling behind. We rebuilt it as software with Software Factory and an 8090 engineer accountable for it and maintaining it, and the cost dropped by about $1.5M a year.