For many of us, the muscle memory of Cmd+P to open a file is as deep as our knowledge of syntax. But for Shan (HanShan), a software engineer with over two decades of experience, that reflex has been replaced by opening a chat prompt. In a recent reflection on DEV.to, Shan details a radical six-month experiment: shipping three complete projects, fixing hundreds of bugs, and refactoring a backend service suite without typing a single line of code into VS Code. The editor icon remains on the dock purely out of nostalgia, a relic of a workflow that has been fundamentally inverted by agentic AI tools.

The Death of the File-Centric View

The transition wasn't seamless. Shan describes the first two weeks as a period of intense cognitive dissonance, where the removal of the file tree felt like losing a mental map of the codebase. Traditional debugging—setting breakpoints, stepping through stack traces, and manually inspecting utilities—was replaced by a "Task & System View." In this new paradigm, the developer defines system boundaries, data structures, and expected inputs/outputs, while the AI agent handles the indexing, branch creation, and execution. Shan argues that this shift revealed an uncomfortable truth: roughly 70% of previous developer time was spent acting as "human code converters," translating intent into boilerplate syntax rather than engaging in high-level system design.

Specification-Driven Development and MCP

To make this workflow viable, Shan adopted three core pillars. First, development now begins with explicit specification documents rather than empty files. These specs define module boundaries, strict TypeScript interfaces, and failure paths, turning code generation into a deterministic execution rather than a creative gamble. Second, Shan leveraged the Model Context Protocol (MCP) to connect AI agents directly to local databases, API inspection tools, and Git repositories. This transformed the AI from a passive chatbot reading pasted snippets into an active agent capable of tracing logic, checking commit history, and running tests autonomously. The debugging cycle compressed from hours of manual investigation to 30 seconds of reviewing diffs and test results.

Hidden Risks in Agentic Workflows

However, this efficiency comes with significant pitfalls that Shan urges builders to watch. The most critical is "hidden architectural rot," where AI agents, favoring local optima, reinvent wheels across files—creating duplicate HTTP wrappers or conflicting constants. Shan mitigates this by enforcing strict project convention files (like CLAUDE.md) that prohibit custom logging or unauthorized API wrappers. Additionally, hallucinated dependencies remain a threat, with AI introducing deprecated or insecure packages that compile but fail at runtime. To combat this, Shan insists on manually reviewing security-sensitive code and enforcing CI dependency audits, noting that AI excels at speed but lacks comprehensive anticipation of edge cases like concurrency or timezone boundaries.

Key Takeaways

  • Developers are shifting from "Producers" (typists) to "Approvers" (architects), with value lying in system definition and critical inquiry rather than syntax speed.
  • Specification quality directly dictates code quality; ambiguity in specs leads to exponential rework in agentic workflows.
  • MCP integration is critical for moving beyond simple code generation to actual tool execution and real-time debugging.
  • Automated verification via robust edge-case test suites is non-negotiable, as AI-generated code often fails in production scenarios like concurrent mutations.

The Bottom Line

VS Code isn't dead, but the era of manual syntax entry is. If you aren't building your workflow around specification-driven agents and rigorous automated verification, you're already behind. The real risk isn't AI writing bad code; it's developers blindly accepting it without understanding the architectural debt it accumulates.