This is really accurate.
As much as we all want to drink the vibe coding kool-aid, the reality is that 90%+ of all code in a company is maintaining and migrating existing stuff that is complicated and messy. You can definitely vibe code the remaining 10% but unless there is a working example of how to reinvent the 90%, AI will not live up to its potential.
We started 8090 and built Software Factory to focus on the 90%.
Many large enterprises now rely on us to help them migrate complex systems, rewrite old systems and maintain existing decisions.
Cheaper, faster and better.
Please consider trying it and seeing what it can do.
"You have to work hard to get your thinking clean to make it simple. But it's worth it in the end, because once you get there, you can move mountains." —Steve Jobs
Narrative violation: The largest AI data center uses roughly the same amount of water as two burger joints. There are over 200,000 fast food restaurants in the U.S. so this is a tiny amount.
We’re launching Cocentives, a commission management system for insurance agencies.
Insurance agencies grind through commission statements from carriers every month. These statements arrive in different formats - Excel files, CSVs, PDFs - with different structures, different column names, different ways of identifying agents. Today, a leader or accountant at the agency has to turn all of this into usable numbers: how much each agent earned, from which carriers, for which policies.
This work takes hours per month at a mid-sized agency and does not scale very well. It’s manual, repetitive, and error-prone. It’s tiring work. Most agencies use spreadsheets. The person who maintains the spreadsheets becomes a single point of failure.
Cocentives replaces this process with an entirely new flow. As files arrive, forward them to Cocentives from your inbox, or upload them in the dashboard. From here, the files get analyzed and read deeply. Cocentives works through your files for you. It extracts the data cleanly, matches your agents across documents and history, calculates the totals, and produces the statements. All you have to do is review and send to your team.
Cocentives uses an advanced multi-analyst architecture to process and work with data. When you upload files, analyzing agents run in parallel to parse different formats simultaneously, extract structured data, and reconcile it against what the system already knows about your agency.
There are no templates to configure. Cocentives talks with you to infer structure from your data and documents themselves. When Co encounters anything ambiguous - an agent name it hasn’t seen before, a commission rate that doesn’t match historical patterns - it asks. Your answer teaches the system and cascades the changes for you. Next time, it won’t need to ask.
Each agency builds up what we call an organizational memory: the carriers you work with, your agent roster, your split structures, your exceptions and bonuses. After processing a few months of statements, the system knows your commission logic well enough to handle new files with less and less intervention.
You interact with Cocentives through conversation or the simple interface options. You can type natural language requests:
“Create a report with the files I sent you for February”
“Open last month’s report”
“Show me the breakdown for agent Mike Torres”
The system interprets these requests and makes action happen for you - opening panels, starting processing runs, surfacing specific data. This is not a chatbot bolted onto a traditional interface. The conversation is the primary way you navigate and control the application. From the ground up, Cocentives is built to be intelligent and fast. Instantly you will notice it is unlike any other software you have used for your agency.
There’s also a standard UI for reviewing results, approving statements, and sending reports to agents. Agents receive their statements via email with a link to an interactive portal where they can view their earnings and ask questions about specific line items.
Cocentives looks simple on the surface. But our simple interface hides a sophisticated and advanced system. We did this on purpose. We want to hide the complexity and only disturb you with the essentials. Cocentives does the rest.
If you want to maximize your agency performance, then Cocentives is perfect for you. Our software is improved every day to support your work. Go to cocentives . com for more.
In 2026, Claude Code could finally unleash the golden age of local and decentralized apps.
The reason is that Claude Code allows you to quickly clone any moderately complex cloud-based app into a decent local one that runs on only your files.
This is an important update to Obsidian founder Kepano’s concept of “file over app.” His argument was that files are portable (and hence more reliable) but apps are not.
The new information is that apps are suddenly portable too. That is: apps of moderate complexity without strong global network effects are suddenly easy to clone. The clone won’t be perfect right away, but it’ll be pretty good. And if the cloning dev sticks with it it’ll get better.
So: can we get a local open source Mac app for everything, operating only on your files? Maybe we can make that a reality.
Effective prompt method for a new app with very high accuracy bar:
Simplified:
```
Message:
Requirements + Instructions + Role + What Not to Do + What to Do + Why + Where the Model Fits In The System
Pass entire schema with inline comments about what it all means. Three wide ranging examples that cover core edge cases and cases.
Pass the raw content coming from parsers.
Output:
Use the <thinking> tags to let the model breath before it outputs the real answer
Use the <json> tag to force model to output in perfect JSON
Force another <final_reflections_json> tag which forces model to add any note worthy things to the output which can be stored alongside the core JSON
```
See comment for open source link adding soon.
Effective prompt method for a new app with very high accuracy bar:
Simplified:
```
Message:
Requirements + Instructions + Role + What Not to Do + What to Do + Why + Where the Model Fits In The System
Pass entire schema with inline comments about what it all means. Three wide ranging examples that cover core edge cases and cases.
Pass the raw content coming from parsers.
Output:
Use the <thinking> tags to let the model breath before it outputs the real answer
Use the <json> tag to force model to output in perfect JSON
Force another <final_reflections_json> tag which forces model to add any note worthy things to the output which can be stored alongside the core JSON
```
See comment for open source link adding soon.