AI as a Context Compiler
The gap between AI effectiveness isn't about tools or models. It's about how meticulously you organize the human thinking that feeds it.
A year ago I wrote how AI was impacting software engineering in my teams. At the time, we saw the productivity impact mostly in greenfield software development. But a lot has changed since then. The capabilities of the early 2026 models have exceeded all our expectations.
At Road.io - a mature fintech platform - we’re revamping product engineering to have a quick feedback loop between domain context, business requirements and AI-powered engineers. Example tools here are MCP integrations to our platform, the company wiki (Confluence) and a repository of domain specific skills.
At Rekall.ai - where we develop products from scratch - the impact is even more profound and has given us an opportunity to rethink how we build software. We’ll be sharing some of these discoveries over the next few months.
Slop Cannons or 100x’ers
LLMs are infiltrating every organization because they are such an effective tool in knowledge work. It’s a disruptive time for organizations where some employees become “slop cannons” and some become “100x’ers”. If you don’t set boundaries and think from first principles, it’s easy to lose your mind - both for the individual and the organization.
What everyone is learning as we use these tools is that garbage in is garbage out. Or as Dan Shipper describes it:
Slop is visible sameness, repeated ad nauseam. (…) It is what gets produced by default when humans in many different circumstances use the same tool, trained on the same corpus, without thinking too hard.
If you leverage agentic AI successfully you will notice a pattern: The effectiveness of agentic AI is highly correlated with the level of human thought that went into it. For this reason any attempt to automate along the lines of “agents as employees” is unhelpful and adding to the slop.
Context is King
In a quickly changing world it is important to think from first principles. At Rekall we’ve been rethinking how we develop software using agentic AI. Some of our observations:
Human thinking is more important than ever. AI is increasing the need and effort of human thinking. It can be exhausting.
Agentic AI gets effective when you provide it with lots of files containing high signal human thinking. If you’re prompting AI without this you are getting slop.
AI requires declarative knowledge. Assembling this context is a challenge even in fully digital organizations like ours.
At the abstraction level of “context engineering” there is an entire universe of methodologies and tools missing. It’s early days still.
Based on this we’ve started to become very meticulous when it comes to bringing together information for AI consumption. We care deeply about human-signal specs (e.g. vision, domain context, business objectives, product ideas) and separating that from the agentic outputs (plans, code).
We’ve developed a directory structure for our AI agents. We’re calling it CRAFT: Context-Reusable Agentic Folder Tree. We use this to organize human signal and agentic outputs. Check it out - feedback very welcome for this first version:
AI as a Context Compiler
Last week an interview by the creator of C++ has been making the rounds. In this interview Bjarne Stroustrup lamented that AI generated code is not ready. It’s too difficult to understand and validate for humans.
There is an irony here: C++ and more specifically C was an abstraction layer that moved us beyond assembly (CPU platform specific machine instructions). It would be shear madness to try and understand, validate and maintain the output of a C++ compiler (the binary/asm output).
If you meticulously track and organize AI prompts and the high signal specs, plans and artifacts that informed the system - these become the new source code.
The agent is the compiler. Your specs are the source code.
If context is source code, the implications follow quickly. Everything we built around code - version control, review, modularity, reusability - needs an equivalent at the spec layer. Most teams today treat prompts as ephemeral: typed into a chat, tweaked, discarded. That's the equivalent of rewriting C++ from scratch every compile.
This is the work ahead: building the methodologies and tooling that turn agentic compilation into a real engineering discipline. Agentic QA. Automated checks on security, performance, and scalability that run every time you compile — the equivalent of catching a syntax error before it ships. The teams that figure this out first will define the next paradigm.