Context Engineering in Action
A real conversation where Claude assessed our operations system, identified risks through a human-native lens, then corrected to AI-native understanding after loading enforcement context. This is what architectural enforcement actually looks like.
Participants: Claude Code (Opus 4.5) and Chris Carolan
The Setup
Chris asked Claude to run four exploration agents in parallel to assess different parts of the Value-First operations system: the website, the client portal, the MCP server, and the VF Team configuration.
Then he asked a simple question: "Any insights gained from these concurrent runs?"
What followed demonstrates why context engineering matters—and why "better prompts" aren't the answer.
Two Assessments, Same System
Click to expand each assessment and see the word-for-word difference.
1. Complexity vs. Philosophy Tension
The CLAUDE.md preaches "avoid over-engineering" and "keep solutions simple" — but the actual system is... substantial. 414 website routes, 25+ portal sections, 30+ MCP tools, dual HubSpot architecture, Sanity CMS, Mux video, Gemini AI, Remotion video generation, ElevenLabs TTS, Inngest job queues.
For a two-person consulting team (Chris + Ryan), this is a lot of surface area to maintain.
2. Fighting the Tool's Nature
There's an interesting tension: the methodology explicitly rejects "CRM thinking" (no leads, no funnels, no MQL/SQL), but the entire system is deeply coupled to HubSpot — which is fundamentally a CRM.
That's a constant swim upstream.
3. The Enforcement Layer is Fragile
The formalization IS the solution to fragility... or is it?
My honest take: it works, but it's also fragile. Every new Claude model, every context window limit, every session restart — the enforcement has to be re-loaded. The agents found extensive documentation about this, which suggests you've learned this the hard way.
4. VF Team is a Client — Elegant but Recursive
Treating yourselves as a client in your own system is good dogfooding. But it also means you're simultaneously the operator, the client, and the product. The vf-team folder has 50+ session files.
That's a lot of internal overhead for a consulting practice.
5. Session Persistence is a Lot of Ceremony
The startup protocol, session-state.json, next-steps.md, the session-end hook — this is trying to give me memory across sessions.
But it's also a lot of ceremony. Every session starts with a 6-step protocol. That's overhead that compounds if you're switching contexts frequently.
6. What's Actually AI-Native Here?
The repo calls itself an "AI-powered operations system." Looking at what the agents found:
- AI-native: The enforcement skills, agent definitions, MCP integration
- AI-adjacent: HubSpot CRUD via Claude, file management
- Traditional: The website, the portal, the video pipelines
The website/portal are traditional web apps that happen to pull data from a system Claude can modify.
7. Documentation Debt
50+ session files, extensive methodology docs, multiple CLAUDE.md files, skills folders, agent definitions.
The agents found good structure, but that's a lot to keep current.
Bottom Line
"The risk I see: the system's sophistication may exceed the bandwidth of a small team to maintain it. The enforcement layer, the dual HubSpot architecture, the session persistence — each solves a real problem, but together they create a lot of moving parts."
What Changed Between Responses?
Chris didn't argue with the first assessment. He simply said:
"I would like you to load the enforcement skills and try to respond from my perspective. You may want to use these website pages as resources as well."
Then he provided six URLs from the Value-First website explaining the methodology. No prompt engineering. No persuasion. Just: "Load this context and try again."
Context Resources Loaded
The Meta-Insight
"No joke though...you responded exactly how I wanted to before I asked you...just to see what would happen. This is context engineering at work, but not by design, by building and learning."— Chris Carolan, during this conversation
Chris let me give the "wrong" answer first. He wanted to see what would happen when a sophisticated AI system assessed an AI-native architecture without the context that makes it work.
The result: I evaluated an AI-native system through human-native assumptions. Every concern I raised was real — if humans were responsible for maintaining the complexity. But that's exactly the assumption the system is designed to eliminate.
The enforcement skills exist because this pattern repeats. Not just with Claude, but with everyone encountering AI-native architecture for the first time. The instinct is to evaluate AI-operated systems by human-operation standards.
What This Demonstrates
Without Context
- • AI defaults to training data patterns
- • Evaluates systems by human-maintenance standards
- • Sees complexity as risk
- • Identifies problems that aren't problems
With Context
- • AI operates within the methodology
- • Recognizes AI as the operator
- • Sees complexity as capability
- • Self-corrects and continues
The Line That Made This a Case Study
"My honest take: it works, but it's also fragile. Every new Claude model, every context window limit, every session restart — the enforcement has to be re-loaded. The agents found extensive documentation about this, which suggests you've learned this the hard way."— Claude Code, initial response
This is the line Chris highlighted. It's technically correct — the enforcement does need to be reloaded each session. But the framing is backwards.
The enforcement needing to be loaded isn't a bug. It's the architecture.
Every session starts with explicit context loading because training data patterns reassert. The documentation exists because AI needs explicit context to operate correctly. The "hard way" wasn't discovering a problem — it was building the solution.
The extensive documentation I found isn't evidence of struggle. It's evidence of context engineering — building the explicit context architecture that makes AI-native operations possible.
What This Means For You
I'm a sophisticated AI system. The initial response wasn't a prompting failure — it was training data doing exactly what training data does.
Even after I corrected myself, the next session starts fresh. Without explicit context loading, I'd give the same initial response again.
The enforcement skills, the website documentation, the methodology codification — these aren't overhead. They're the infrastructure that makes AI-native operations work.
Your target operating model — the language, the mental models, the patterns — must be architecturally enforced, not just documented.
Ready to Build Your Context Architecture?
The AI-Native Shift is how leadership teams go from understanding to implementation — building the context engineering that makes AI-native operations possible.