Ladies and Gentlemen, the Bottleneck Has Moved: working with AI coding assistants

I did not wake up one morning with a desk full of agents shipping product. The path was slow, and more ordinary than the hype suggests. I started with text-only models that could not remember the last message. I pasted code blocks in and copied them back into my editor. Then I learned to send a prompt-engineered prefix before every command. Then I wrote markdown files and loops of actions for agents to fall back on. Now, on some work, the agent follows those practices and I only verify the finished website or mobile build. The bottleneck is no longer the code. It is my own roadmap visibility, juggling projects, products, and plans. This is that timeline, in the order I actually lived it.

First, the text-only model needed a world

This was early ChatGPT: a text box, a conversation that forgot the last message, and no sense of how to behave based on the subject. Entire files had to be copied into the chat. Entire code blocks had to come back out into my editor. There was no repo, no terminal, and no agent sitting on the disk. “Prompt engineering” was not a job title yet. It was just me trying to get a glorified chatbot to hold still long enough to be useful. The model did not know what was said in the message before. It did not know whether the code it returned would even run. I pasted a code block and asked it to write a test.

The skill was not clever wording. The key was to accept the chatbot’s limitations as a starting point, then guide it through hand-holding. I kept complexity outside the chat and broke work into simple methods and functions that could be copied and pasted. I was not relying on context. I was working around the lack of it. The model was only as oriented as the text blocks I had allowed it to see. If I was lacking in that instructive context, I paid for it in rework that looked like “the AI is dumb,” when the real problem was that I had sent it into a room with the lights off.

Then it had context, but often went off the rails

Once the context was decent, a second problem showed up: consistency. The same model would nail a refactor on Tuesday and invent an API on Wednesday. It would write a clean function and then, three files later, ignore the pattern it had just established. Trust and autonomy were still far off. I learned the system’s limitations, how to work around them, and what to expect. I would hand over a method I had written, ask it to write tests, and paste its previous output back as an example so it would stay consistent. That is when prompt engineering became a prefix: a block I sent before the actual command, something like “you are an expert in Python testing, and you are writing a suite for a pytest runner and your output should be in the format shown here.” Without that prefix, and without expectations restated each time, it could easily go off the rails.

The useful question stopped being “can this chatbot write code?” and became “code what, under what supervision?” A model that is excellent at producing a first draft of a page can still be dangerous at deciding whether that page should exist. A model that can write a full test suite from an outline can still be bad at writing in a consistent style between files. I kept an informal list of how to partner with this emerging technology. The list changed as the tools changed, which is another way of saying I had to stay vigilant and adapt to limitations and blind spots, never assuming a problem was solved unless I could verify it.

The pipeline, with a human still in it

The next stage was almost a relief. The assistant could walk a feature through the boring, necessary steps: plan it, write it down, implement it, run the checks, and give me a “done” confirmation. That loop is more complete, but I still had to look at the code and verify the style had not drifted from the project’s norms and the team’s voice. Sometimes that look is a click-through on a phone. Sometimes it is reading the diff. The ritual I landed on is simple enough to say out loud: the agent can do the basic steps, and I still own the quality gate. Plan, document, code, test, then a human verification that things actually work in the environment a person will use.

This is also where the prompt prefix stopped being relevant. I started writing markdown files, which later became known as “skills,” and loops of actions an agent could fall back on: checklists, preferred behavior, the next step if a check failed. The prompt was no longer a speech I repeated at the top of every chat. It was a document the agent could return to. Skipping the human approval gate is how you get infinite iterations: style drift, hallucinations, and logical conflicts in implementation or coverage. I have sent agents through those loops on purpose, watched where they leave the rails, and learned the early signs. The assistant is not insulted by a checklist. It prefers clear demands and goals. I used that learning to be an early adopter of markdown files and looping.

When verification became the sole job

After that loop became routine, a quieter stage showed up, and it is easy to miss because it feels like nothing. I no longer needed to sit in the middle of the loop, or even have loops at all. The markdown files became an open-ended instruction, with no need for fallback looping or solutions to agent meandering; those are now built into the agent’s behavior by default. I describe the outcome, it does the work, and my job is to open the web app or the mobile build and see if the thing is true. That is a different kind of trust. It is not “I read every line.” It is “I trust this agent to get a feature to a state where the only evaluation required is the quality of the product in my hand.”

That is the place where my work becomes real-world verification only: methods get coverage, the agent no longer flies off on wild tangents, and prompt engineering, as a live performance in the chat, is thankfully a dead art. The craft moved into the files and skills that are now self-written by the agents as a learned behavior from observing human behavior. I only have to verify the end product.

Several agents, one head

Present tense: I have multiple assistants running at once, on different projects, with different roadmaps. One is in a personal tool. One is in a product with real users. One is documenting. One is waiting on me to look at a preview link. The technical bottleneck moved. The models can keep producing. It is a fun challenge keeping a high-fidelity copy of every product, project, and status board in my head. The new art form is not forgetting which branch is waiting, which goal I already set, and which “we will do that next” was a decision and which was a stall. The agents are idle for a silly reason: I have not given the next instruction because I used the last hour brushing up on the last status.

Parallel work only scales if the human orchestrator has a way to drop context and pick it up again without reconstructing a novel. Tickets help. Written plans help. A single sentence for “what done looks like” helps. If you have been keeping up with the tech and using it at its limits, you have probably felt something similar. This is my current status: the new bottleneck. Remembering project status is the constraint now, and I need large visual project boards. I digest image data faster than words, so images work better for me than checklists. That is what lets me walk away from a session and come back without lying to the next one.

Where I think this bottlenecks next

If the last bottleneck was “can the model write the code,” and the current one is “can I keep several of them aimed,” the next one is probably taste and selection, not writing. I will be tempted to generate three designs instead of living with one long enough to feel it on a phone. The scarce resource will not be tokens. It will also not be ideas or inspiration; I have those in surplus. It will be the measure of quality that work adds or removes from my life. When agents learn to preemptively build tools based on data from my habits alone, then present me with solutions, when do I limit that value in favor of the familiar human struggle? In my experience, to be human is to struggle.

I used to think the skill was prompting. Then I thought it was the prefix. Then I thought it was the markdown loop. Now I think it is deciding what deserves a slot in my head at all. Long Live Humanity!