The Question Is the Constraint

Code stopped being the constraint. So did capacity. What's left is whether you can ask the right question.

Muscle memory isn't in the muscle. We don't often think of it that way, but at its core, muscle memory is mental. It's new neurological pathways being developed. Whether it's dribbling a ball, learning to draw, or developing new problem solving skills, they all require your brain to re-wire itself. That rewiring takes time, deliberate practice, and a healthy sleep schedule.

But as with any learning curve, there is the steep part of the curve, which sucks, but is crucial. That effort is what drives the new connections to form. The deliberate practice, the "stress" of practice, studying and working hard on something new. As those connections click into place, that curve flattens out. Subsequent steps get easier.

Thinking in AI is very different than previous digital adoption or transformation. It requires building new pathways and ways of thinking about problem solving. It requires everyone to advance their working model "up a level", in what they are directly supervising. If you're an IC, now you're a team lead for an agent team. A team lead, is now leading multiple teams, etc. That's a steep enough curve under normal circumstances, but now we're able to realize that scale almost overnight. At least in theory.

No matter where you're at on the learning curve, you cannot get good at something unless you actually do it. I've made that case already, so I won't repeat it here.

Problem solving itself changes. There are a few different models out there. I'm going to walk through the progression that most people go through, and where there's the potential to get stuck, if you don't have the right level of AI-native technical enablement. Where it ends up is the part worth sitting with: the constraint stops being capacity and becomes the question you think to ask.

Also, it's worth noting that the landscape of AI is super confusing with many overloaded terms that are not equivalent. Just to keep this simple, I'm going to refer to the harness and the model as separate things. Harnesses are things like Microsoft Copilot, Claude Cowork, GitHub Copilot CLI, Codex. It's the interface that people use to interact with the underlying Large Language Model. The Models are the frontier models like Claude Opus, OpenAI GPT, or Gemini. Harnesses use models, and often will have models available from a myriad of foundational model companies.

Level 0: First exposure

The easiest and most basic, is treating AI like a more powerful version of Google search. I put something in, and I get something out.

The chat interface follows a stream of consciousness flow. You upload documents into the chat. It can leverage connectors to search and pull in additional context, but it's basically a long running conversation where you may create one or more artifact documents that you then save / download and then repeat the process.

The human is providing the integration, as well as the feedback loop. You can't spin up an agent team from these interfaces. There's some orchestration like web search, working through tasks, but it's shallow.

Level 1: Efficiency

Once you've poked at the chat interface for a bit, the natural next move is to point it at the work you already do. You draft emails faster. The PDF you'd been dreading slogging through? Skimmed in seconds. Status updates that used to eat an afternoon now take five minutes. It feels great. And it should. You are getting more done.

But there's a ceiling here you can't see at first. You can only make an existing system so efficient. The shape of the work hasn't changed. You're just running the same loop quicker. This is a finite game.

Level 2: Restructuring the work itself

This is the level often glossed over. Technically it's still efficiency. The shape is different, though. You're problem-solving across a different dimension. You're thinking about the problem in a way the old toolset didn't allow.

Take code analysis. Historically, if I was trying to do a broad refactoring, it would require going repo by repo. I'd have to pull down, determine the current working branch, grok the structure, and continue processing each repo serially. One at a time. In order. With an agent team, the unlock is serial-to-parallel. The task is the same. The shape of how I attack it is different.

Move from serial to parallel wherever you can.

As part of this you have to move from "being in the middle", to delegating out. This is the "up a level" shift from the top of this post, made concrete. The middle level is where you discover the substrate you'll need for the level above. Leveraging connectors (multiple connectors), Command Line Interfaces (CLI), and context sources to dramatically accelerate your ability to pull in, synthesize, and fan out to multiple threads. The connectors you build here are the infrastructure for what comes next. Treat it as such.

Examples from my work

Everyone's AI patterns are different. These are a few examples of how I personally use AI in my own work, and every one of them is a Level 2 move where the shape of the work changed, not just the speed.

Native inputs across modes. I encode and ideate best with a pen in my hand. Writing is how I think. Visual is how I express. That used to mean a transcription tax. Now I write by hand. I snap a picture. The transcription agent does the rest. I draw on paper or a whiteboard. I snap a picture and drop it wherever it belongs. Claude Code, Claude Design, My Obsidian context store. A terminal window. I talk to my phone while I'm out and forward the audio to the right agent. Coding. Note-taking. Riffing. Reminders. I transcribe every meeting and pipe the notes into my context store. I still encode in my preferred mediums. The substrate converts to an AI-native one immediately.

Curated context. Garbage in, garbage out. The fix is curation. I use a combination of Obsidian + Claude Code with custom skills and folder level AGENTS.md instructions. Let one ingest what's incoming. Let it organize what's stored. Let it keep the whole store cohesive. Data virtualization and query federation are the right shape for this. Leave the data where it lives, query across it. You don't need to move everything into one uber-warehouse. You'll never get there anyway. All you need is access and the ability to index. Two query interfaces work best. One that's API or search-driven. One that's agentic. Build a skill that knows when to use which.

Single-use tools. "Throwaway code" used to be an insult. Not anymore. With AI, the cost of construction is so low that you should look for every chance to build a single-use tool. AI tools are great at generating lightweight web based (HTML), and command line (CLI) tools. Instead of a static diagram you can build an interactive reporting tool with sliders, search, and filter criteria on top of existing APIs.

The wall of enablement

At some point, as you're trying to delegate more to AI, you're going to hit an artificial wall. It's the "wall of enablement". You want to delegate scheduling a meeting, but the calendar connector is read-only. You want to have an agent tail the log streams for several services during a deployment, but the connector is not enabled. I could give hundreds more examples, but this is where organizations really have to push through to enable AI-native capability for their toolset of choice.

Many organizations stall at the model+harness level because AI is viewed as "just another tool", or application. Through that lens, it's seen as "I bought the tool, now give me the results." Buying the tool is step one. There's an enablement layer required underneath. A foundational AI substrate that has to be in place before the tool unlocks anything.

Imagine you bought a PC today and it came with no network card. No wireless. No way to connect to anything outside itself. Then someone says, "well, just look that up on the web." You can't. There's no connectivity. You can't get from point A to point B.

That's where most enterprises are right now with AI. They bought the tool. The AI-native enablement underneath isn't there. No substrate. Nothing for the tool to plug into. The value is locked behind a layer that hasn't been built yet.

The good news is that most major vendors now offer first-party connectors for their products, including user level authorization that matches access permissions for web based interfaces.

Don't stop at connectors, because the models are only as good as their context. Curated, high signal context stores are also a must. Don't try to force a monolithic store as it will get bogged down by too large of a scope. Focus on creating high trust, curated content close to domain and functional area expertise. The subject matter experts (powered by their agent teams) are going to be way better and faster continuously curating, publishing and updating.

Level 3: Insights

This is the next-level unlock the connector infrastructure makes possible. Insights you'd never assemble one step at a time. They emerge from connectors firing in concert across parallel work. The finite efficiency game gives way to an open-ended insights game.

The unlock is something you almost don't realize until you stumble into it. Give the models the right access to the right context with the right tools, and they start seeing patterns you couldn't see at first glance. Then they coach you through them. The system surfaces what you'd never have found by asking the way you used to ask.

Anyone who's run multiple agents at once has felt the small version of this already. I wrote about it in the first post: it's hard to stay ahead of them going idle, waiting on you. At Level 3 that stops being a tooling annoyance and becomes the thing that governs the whole system.

Which lands on the thing I keep coming back to.

The bottleneck has become asking the right question.

Frame this through lean and the theory of constraints. For decades the constraint was capacity. The models have collapsed the cost of execution. The constraint moves. The new constraint, the one actually rate-limiting at the top of the curve, is whether the leader (or the individual) is asking the right question.

That post landed on creativity as the constraint that doesn't compress. This doesn't replace it. Creativity is what has to happen. Question-craft is how a person actually exercises it against a substrate that can answer. The bet on what's worth making at all still arrives as a question somebody had to think to ask.

Sit with that. The job of leadership shifts. It used to be "deploy resources at the problem." Now it's "ask the question that unlocks the system." Ask the wrong question and your massively-parallel AI substrate runs hard in the wrong direction. You scale waste. The rate function multiplies whatever you point it at, including the wrong thing. Ask the right question and the system answers in a way no serial process could have. The question is the leverage point.

Skip Level 2 and you don't get here. You stay capped at efficiency, and your ceiling is the size of your existing process. The orgs that win invest in connector-building during the efficiency S-curve, because that's what carries them across into the insights one.

Once you're on the insights climb, the work shifts again. The substrate is doing the lifting. The constraint is the question. The discipline of the climb is question-craft. Figure out which questions unlock the system. Ask them. Let each sharper next question come into focus on the strength of what you just learned. The steep part of this curve is question-craft itself.

If there's one instruction to take out of this, it's this. Build the connectors before you have a use for them. Do it while it still feels premature. That substrate is what carries you from one curve to the next, and it never gets built in the moment you finally need it.

Exhilarating and humbling

I ended the last post on humbling and exhilarating. Both still hold, and at this level they arrive at the same time. Exhilarating because of the speed. Things that would have taken days to surface arrive in minutes. Humbling because the substrate is doing things you never could have done alone, and once you've felt that, you can't unfeel it.

The pattern recognition is yours. The execution is the system's. Together you outrun the version of yourself that worked without a substrate.