I recently watched my simple Antigravity AI agent take a SQL competency test. It didn’t just pass; it nailed a 9 out of 9 score, deftly handling subqueries, window functions, and WHERE clauses that usually trip up human analysts after their third coffee.
This wasn’t a parlor trick. It was a litmus test for a thesis I’ve been chewing on for months: The capability to solve problems via software engineering is rapidly flowing downstream.
For the last decade, we’ve bifurcated the world into “Developers” (the high priests of syntax) and “Users” (the click-and-hope crowd). Somewhere in the middle sat the “Makers”—the no-code warriors of Coda, Notion, and Airtable who learned just enough logic to be dangerous at times and extremely helpful otherwise. We owe this cohort immense gratitude for the operational clarity, cost savings, and innovation they have delivered.
But as I reviewed the results of that SQL competency test—run in a Coda doc connected to a local SQLite environment via MCP—I realized something profound. The dam has broken. The rigid discipline of software engineering is no longer trapped upstream in the Engineering Department. It is flooding the valley of general knowledge work.
Most enterprise middle managers are sleepwalking into the rising water.
The Upstream/Downstream Dynamic
In a recent discussion on the Coda Maker Community, I noted that enterprise leaders are missing the point of AI agents. They see “chatbots” or “content generators.” They see a faster way to write a mediocre email. Or a lazy path to summarize texts, much of it poorly.
What they should be seeing is the democratization of deterministic reasoning.
“Enterprise middle-managers are sleepwalking into a future where it is common to believe and accept that almost any problem/solution can be expressed in software. What they are missing is that this capability is upstream of all knowledge work.” — Bill French
Currently, I’m consulting on a project involving the modernization of COBOL systems—mainframes that have been humming since the days when Star Wars was in theaters. These systems cannot fail. “Hallucination” isn’t a cute quirk here; it’s a lawsuit or an ATM that doesn’t give you your own money. By crafting a formal agentic framework using modern reasoning models, we are seeing two to five nines of competence.
This is the Upstream reality: Formal, agentic frameworks that convert natural language intent into deterministic, flawless code execution. But let’s expand on the term “code execution” to include an agent that opens a Coda document, analyzes the related views, and magically modernizes it to use the new tabbed views feature.
The Downstream reality is what happens when those tools hit the marketing department, HR, or sales operations. The ability to structure a problem, break it into logical steps, and implement it in code (even if you never write a line of Python or CFL yourself) is becoming a baseline requirement for employment.
Vibe Coding and the Death of Syntax
Andrej Karpathy coined the term “Software 2.0” to describe neural networks. But we are arguably entering “Software 3.0,” or what the internet, in its infinite wisdom and irreverence, has dubbed “Vibe Coding.”
Aakash Gupta recently highlighted this shift. We are moving from a world where you need to know the syntax (where to put the semicolon) to a world where you need to know the vibe (what is the user actually trying to achieve?).
A Note About ‘Vibe’
Don’t get hung up on this term. It reflects a general lack of due diligence, yielding imprecise outcomes. Ultimately, we align with AI agents to drive precise, actionable outcomes. Vibing is no different than contexting. The better your vibe, the better the outcomes.
The entire industry is pivoting to this “Agentic Generalist” model on the heels of tools like Claude Code:
- Google Antigravity: This isn’t just an IDE; it’s a “productivity platform”. While initially pitched as a “Cursor Killer” for devs, it’s finding a massive foothold in Product Management and Marketing. Why? Because it offers an “Agent Manager” surface where a PM can say “Build a campaign timeline,” and the agent autonomously plans, executes, and tests the result. It’s software engineering applied to Gantt charts.
- Claude Cowork: Anthropic just dropped this “Claude Code for the rest of us”. It doesn’t just chat; it stares at a folder on your desktop and does the work—organizing spreadsheets, renaming files, and executing multi-step workflows that used to require a junior analyst.
This is terrifying for purists. It’s liberating for everyone else.
In the Coda ecosystem, we are seeing this collision in real-time. The “Old Maker” spent hours learning the intricacies of Coda formulas, RunActions, and layout hacks. They took pride in the complexity of their docs.
The “New Maker”—enabled by tools like Coda MCP and mcpOS™—doesn’t care about the formula. They care about the reasoning.
mcpOS™ (my own framework for integrating agentic reasoning into Coda) is proof of this. It allows a Coda doc to stop being a static repository of text and start being a dynamic operating system that can:
- Read its own schema.
- Query external databases.
- Test its own hypotheses.
- Reason about the data it holds.
- Validate its work.
The 10x Productivity Lie (It’s Actually higher)
We love to throw around “10x engineer” as a mythical creature. But with extreme context engineering—feeding agents the precise schema, rules, and constraints of a system—we aren’t just making engineers faster. We are making non-engineers capable of engineering feats. Or Makers capable of compressing time while expanding opportunities to enrich enterprise workers.
-
If I can instruct a Coda MCP agent to “analyze the sales data from the last quarter, identify outliers based on standard deviation, and draft a report explaining why the Midwest region is underperforming,” and it executes the SQL, runs the Python analysis, and writes the prose—what am I?
-
If I can refactor twenty Coda systems to utilize the latest advanced features, test the changes, and document the changelog for three hundred users—what am I?
I am no longer a “Manager.” I am the architect of a software system that performs management tasks. I am the orchestrator of a team of agents that transforms me into a Superhuman Maker.
This is the “profound impact” I mentioned in the Community thread. The distinction between “managing people” and “managing code” is blurring as tools that require code-like instructions proliferate, and code is becoming sophisticated enough to act like people.
The Determinism Defense: A Case Study in Reasoning
“But Bill,” I hear the skeptics whine, “AI hallucinates! It lies! It makes things up!”
Yes, if you use it like a drunk intern. But if you use it as an engineer would, it works with decisive intention guided by your vibe (i.e., your instructions, a constitution, a context).
Take a look at the Competence Report generated by my SQL agent. This is the smoking gun for why mcpOS™ and tools like Antigravity are revolutionary.
Look at the “Failures and Corrections” section:
- The Failure: In a “Nested Subqueries” puzzle, the agent initially failed because it forgot that SQLite performs integer division (e.g.,
88 / 95becomes0, not0.92). - The Correction: It didn’t just give up. It analyzed the error, applied a fix by casting the denominator to a float (
score / (max_val * 1.0)), and re-ran the query. - The Result: Success.
This is reasoning. It is the scientific method applied at the speed of silicon. A standard LLM chatbot would have just hallucinated a number, and when corrected, it would tell you, “You’re absolutely right!”. An agent running on mcpOS™ engineered a solution because it includes as part of its constitution this:
### 3. Verification & Testing
#### Automated Tests (Browser Subagent)
We will use the Browser Subagent to perform visual verification:
- **Test Case 1**: Verify Tab Existence
- Check for DOM elements corresponding to the tab headers: "Table", "Timeline", "Kanban".
- **Test Case 2**: Verify View Switching
- Click "Timeline" tab -> Verify Timeline view acts active.
- Click "Kanban" tab -> Verify Board view acts active.
Explicit contexts (vibes) like this are how we are modernizing 40-year-old COBOL systems without melting the financial sector. And it is how a Marketing Director using Google Antigravity will eventually run their entire campaign attribution model without asking the data science guru for a favor.
The Coda Maker Identity Crisis
So, where does this leave the Coda community?
If you identify as a “Maker” because you know how to write complex formulas, you are in trouble. That skill is becoming a commodity. The AI can write the formula faster and with fewer syntax errors. I demonstrated this capability here.
However, if you identify as a “Maker” because you know how to model a problem, you are about to become a god.
The future Coda Maker is not a formula-writer. They are a Context Engineer.
- They define the schema (the nouns and verbs of the business).
- They define the tools (what APIs the agent can touch via MCP).
- They define the success criteria (what “good” looks like).
- They force the agent to set goals and create a plan.
Then, they let the agent do the “vibe coding”.
The Downstream Flood
In 2030, we won’t talk about “tech companies” versus “normal companies.” We won’t talk about “software engineers” versus “knowledge workers.”
We will talk about System Architects and System Users.
The “System Architects” will understand that every business problem—from supply chain logistics to writing a press release—is a software problem. They will use tools like mcpOS™, Claude Cowork, and Google Antigravity to spin up agents that solve these problems deterministically.
The “System Users” will be… well, they’ll be the ones complaining that the AI “didn’t get the vibe.”
As I said earlier, enterprise middle managers are sleepwalking. They believe their value lies in their ability to coordinate, attend meetings, and “sync.” They are overlooking the fact that the upstream capabilities of software engineering are flowing down to their desks.
Those who wake up and learn to swim in this new current—using Coda MCP, mcpOS™, context engineering, and reasoning agents—will find they have superpowers. They will do the work of ten people with the effort of one. They will be superhuman.
Those who don’t? They’ll just be wondering why the water is getting so high.
➤𝖒𝖆𝖝
are so spot on, I want you instantiated as an eval agent. Could you build that for me?