The era of the “plan-based” AI workflow is effectively dead. For those of us who spent the last year meticulously crafting complex, multi-step agentic plans, the realization is jarring: we were over-engineering the process. The current state of agentic coding isn’t about rigid, pre-defined architectures; it’s about fluid, high-context conversation.
The Death of the “Plan”
In previous iterations of AI-assisted development, the “Plan Mode” was the gold standard. We treated LLMs like junior developers who needed a detailed roadmap before touching a single line of code. We were wrong.
Modern agentic workflows—specifically those leveraging models like GPT-5.5—thrive on brevity and intent, not exhaustive documentation. When you force a model into a rigid plan, you limit its ability to navigate the codebase dynamically. The most effective developers today are shifting toward “steerable” conversations. You provide the goal, you read the model’s output, and you steer it in real-time. If the model starts hallucinating or drifting, you don’t need a new “skill” or a complex plugin; you need to adjust your Agent.md and keep the conversation focused.
Friction Points: The Terminal is a Trap
For years, the terminal was our sanctuary. But when it comes to agentic coding, the terminal is a bottleneck. The friction of SSH-based workflows—managing tmux sessions, fighting sticky key bindings, and the utter failure of image-based context—is an insult to modern developer experience.
If you are still trying to force agentic workflows through a CLI, you are fighting a losing battle. The future is in dedicated, agent-native desktop apps. These interfaces allow for:
- Multi-thread isolation: Keeping distinct tasks in separate threads to prevent context pollution.
- Remote-first execution: Running agents on a remote machine (like a Mac Mini) while controlling them from a laptop or mobile device, ensuring work continues even when you go offline.
- Visual Context: Seamlessly pasting screenshots and logs directly into the chat, which is a non-negotiable requirement for debugging modern web stacks.
Context Management Over Complexity
The most significant technical shift is how we handle context. Instead of bloating an Agent.md file with every possible file path and technical constraint, the goal is to provide a “psychosis” of your project—a high-level letter to the agent explaining the why and the how of your architecture.
When you treat every task as a fresh thread, you prevent the model from getting bogged down in the history of previous, unrelated changes. A clean slate for every feature or bug fix ensures that the model’s attention is focused on the current problem. If the model needs to understand a complex interaction, don’t write a 5,000-line prompt; provide a simple, working example. The model will extrapolate the logic far more accurately than it will follow a complex, written specification.
The Shift Toward Agent-Native Substrates
We are moving toward a world where the framework itself is designed to be consumed by agents. We are seeing the rise of “agent-native” app substrates—frameworks that expose their entire API surface through CLI commands or SDKs that are explicitly documented for AI consumption.
When your infrastructure (DNS, database, auth) is as programmable as your application logic, the agent stops being a code-generator and starts being a systems engineer. You aren’t just writing functions; you’re orchestrating deployments, managing DNS records, and verifying state, all through a conversational loop.
The Final Takeaway
The industry is currently obsessed with “tooling up”—installing every available skill, plugin, and framework to make the AI “smarter.” This is a coping mechanism. The reality is that the models are already smart enough. The bottleneck is no longer the AI’s capability; it’s our inability to communicate effectively with it.
Stop looking at the code and start looking at the conversation. If you find yourself spending more time reading the code output than the text surrounding it, you’ve already lost the thread. The most productive developers in this new paradigm are the ones who treat the AI as a collaborator, not a subordinate. Keep the prompts simple, keep the threads isolated, and for the love of everything, get out of the terminal. The future of software development isn’t in the CLI; it’s in the conversation.