Senior Director @Dell. Exploring how AI becomes organizational capability. Working with builders to shape the future of enterprise AI. Views are my own.
Joined May 2015
- Tweets3.7K
- Following1.2K
- Followers24.3K
- Likes8.3K
Pinned Tweet
I visited OpenAI, Anthropic, and Google looking for the winner for the Enterprise.
I found three.
That evolved my thinking enterprise AI architecture.
The durable layer should be the capability not the model vendor’s offering.
In a market where the winner keeps changing, optionality becomes architecture.
Is “It worked when we deployed it” becoming the new “it works on my machine.” when working with agents?
Building an enterprise-ready agent felt like the hard problem. With the model drift happening, keeping it that way may be an even bigger one.
Imagine the refactoring necessary for 1000s of agents based on a model version when it gets deprecated.
There’s a lot of fear around AI.
Here’s one area where I think it will enormously help people:
Customized coaching for almost any skill.
Feed it the best books, talks, and examples from people who’ve mastered the craft. Let it synthesize the patterns, generate practice exercises, and critique your work.
It will compress your learning timeline.
“Don’t test quality in” is one of the oldest lessons in software engineering.
Building AI agents just highlighted for me where that advice breaks down.
In one agent, moving quality upstream produced a 72× improvement.
In another, it made performance worse.
Interestingly, difference wasn’t the model it ended up being the determinism of the task.
AI consumption is what IT measures.
% business capability agentified is what leadership will need to measure.
Are you asking your AI agents to do too much?
Everyone is trying to give agents bigger and bigger jobs.
I got one to build an entire application by doing the opposite.
The #1 mistake I see novice AI users make has almost nothing to do with prompting.
Natural language makes complex systems easy to specify.
The complexity is still there. It’s just written in English.
Build small incremental prompts as steps. Prove them. Layer on more capability. Prove the stack again.
One of the biggest risks of coding agents may be the thing that makes them so valuable:
Speed.
We’ve spent decades saving code while discarding the decisions (context) that created it.
Developers carried much of that missing context in their heads.
Coding agents don’t.
Now context debt can accumulate at machine speed.
Crazy, my neighbor’s surveillance camera caught the lightning strike on their house that caused outages for us last night. Anybody know what causes the residual gray streak the frame after the strike?
Did AI break Agile?
The strangest thing I’ve done with a coding agent was delete the code after it finally worked instead of refactoring it.
After years of doing Agile, what I did next felt surprisingly waterfall:
I wrote a 50-page specification and rebuilt the entire thing from scratch.
The rebuild was cleaner.
At the SDLC level, I think a new loop may be emerging:
Explore → Converge → Specify → Rebuild
The future artifact of iteration may now be the specification you earned by building it.
I think this sentiment extends beyond coding to general work/content creation. We now have an AI amplifier for all of our work. As it gets easier to just hand work to AI, we have to apply judgment on where to focus our deep involvement.
my take is that ai has made it almost impossible to tell how much care someone actually put into a pr
i don't necessarily care if ai wrote all of the code. i care whether you understand it, tested it, refined it, and stand behind what you're asking me to review and ship.
when the code, description, and even responses to review comments are generated, how do i know you did anything beyond generate and move on?
if you're asking someone else to carefully review your work, you should have carefully reviewed it first.
Context engineering asks: What should the model see right now?
Graph engineering asks: How should knowledge be represented so the right relationships can be retrieved at all?
That makes graph engineering less of a successor and more of a knowledge architecture underneath context engineering.
A Chinese developer just explained the shift from Loop Engineering to Graph Engineering better than anyone.
most people are still building agents the way that's about to be obsolete.
> why single-agent loops break and go "goal blind"
> the 4 parts of a graph: nodes, edges, state, policy
> 3 topologies that run everything: diamond, supervisor, pipeline
> Anthropic's 5 official workflow patterns
the punchline: it's not how many agents you run. it's the determinism you build with verifiers, code fallbacks, and reality anchors.
I broke the same architecture down with Kimi K3. Full A-Z guide below.
