# I Don't Write Code Anymore: How I Develop With AI Agents

> Source: <https://dev.to/techoptio/i-dont-write-code-anymore-how-i-develop-with-ai-agents-5535>
> Published: 2026-11-21 01:29:28+00:00

**Recommendation:** For anything beyond a one-line fix, have the coding agent investigate the repository and produce a Markdown plan for your correction before authorizing implementation, then scope each agent to a small, reviewable PR.
More in the playbook "Working with AI coding agents": <https://wpnews.pro/playbooks/coding-agents>

A couple of years ago, I was writing thousands of lines of code a year. Today, I don't really write code anymore.

That sounds more dramatic than it is. I still work on software every day, and I still need to understand what the code does. But whether I'm implementing a large feature, changing one line, investigating a bug, or configuring infrastructure, my first move is usually to ask an AI agent.

This happened gradually. First came autocomplete and helpful code snippets. Then agents became reliable enough to work on complete functions and features. Throughout 2026, the improvement has been extraordinary. I've gone from using AI as a coding assistant to building almost my entire workflow around it.

**The biggest change isn't just that I type less. It's that I can work at speeds that weren't possible when every implementation depended on me.** I can have multiple agents progressing on different features and projects while I review plans, answer questions, and decide what ships.

Here's what that workflow looks like in practice, what it costs, and why I still think knowing how to program matters.

I used to approach a task by opening the relevant files, figuring out the implementation, making the edit, and running the tests. Now I start by describing the result I want.

That might be a screenshot with a requested UI change, a feature description, or simply, "Why is this page slow?" I don't need to tell the agent which function to edit before it's had a chance to inspect the project.

I still decide whether an implementation makes sense. That responsibility hasn't disappeared. In fact, the ability to generate code so quickly makes it easier to create a *lot* of the wrong code if I haven't thought through the problem first.

That's why one habit has become especially important to me: **plan before building**.

I use [Cursor's Plan Mode](https://cursor.com/docs/agent/plan-mode) for anything larger than a straightforward tweak. My first request describes the desired outcome and asks the agent to investigate the repository and propose an implementation plan. It doesn't authorize the implementation yet.

*I use Plan Mode to find problems with an approach before the agent starts writing code.*

The initial plan usually needs some corrections. Perhaps the agent missed an existing abstraction, misunderstood how something already works, or proposed an unnecessary change. I reply with short corrections and let it update the plan.

Once I'm satisfied, I ask it to implement the approved plan. The plan itself is saved as Markdown, with the approach and individual tasks spelled out, so I don't have to repeat everything in another prompt.

I've accumulated nearly **2,000 saved plans**. That isn't a count of completed features or conversations; it just illustrates how routinely I work this way.

For a one-line fix, I usually skip Plan Mode. I still let the agent make the edit.

I rarely give an agent a huge, vaguely defined feature and tell it to build everything at once.

Instead, I tend to follow this process:

This gives each agent a manageable scope. It's also much easier for me to review, test, and catch mistakes in a smaller PR.

My agents also work with persistent Markdown rules and reusable skills. Some are general preferences, and others are specific to a repository.

For example, the agent working on my WordPress site already knows that starting a local Docker stack isn't enough when the task needs actual website content. It knows how to prepare a usable environment, which files should own theme changes, and what the normal deployment process looks like.

I don't paste those instructions into every conversation. The relevant rules and skills are already there.

Cursor happens to be my daily client, but none of these ideas depend on Cursor specifically. I could use the same approach with [Claude Code](https://code.claude.com/docs/en/overview), [Codex](https://openai.com/codex/), or another capable coding agent.

It's useful when one agent can implement something faster than I can. It's far more interesting when **several agents can work on separate problems simultaneously**.

I might have one agent investigating a bug, another implementing a feature, and another working on an entirely different project. Instead of completing each task sequentially, I move between agents to clarify requirements, inspect plans, and review results.

Of course, parallel development creates its own coordination problems. If two agents edit the same files or share a mutable development environment, their changes and tests can interfere with each other.

I've become heavily dependent on [Git worktrees](https://git-scm.com/docs/git-worktree). Each worktree gives me another working directory tied to the same repository, so agents can develop different branches without constantly overwriting each other's local changes.

For web development, I also run separate development server instances on different ports. That lets each agent use and test its own version of the application.

This is particularly useful when several issues are being implemented at the same time. One agent can be running browser tests against its worktree while another is changing an unrelated feature elsewhere. Each can produce its own PR.

It doesn't eliminate integration work. I still have to watch for conflicting changes and make sure independently implemented pieces fit together. But it removes a lot of unnecessary waiting.

I've also started experimenting with cloud agents. These can work in their own remote environments without tying up my local computer, even when it's turned off. They can implement tasks, run tests, and prepare PRs for later review.

I'm still a heavy user of local worktrees and development servers, but remote agents make the idea of parallel development even more interesting heading into 2027.

This approach applies to debugging, too.

When something breaks, I often ask an agent to investigate the root cause and find reproduction steps **without changing anything yet**. I want it to trace the relevant behavior, examine the code, and explain what it thinks happened.

A question like "Why is this slow?" should remain an investigation. "Should we fix it?" should produce a recommendation, not an unsolicited implementation.

Once I understand the problem, I can approve a fix or request a plan for a more complicated change.

Sometimes I'll use a stronger model to investigate a difficult issue, then hand the approved implementation to a cheaper model. The expensive reasoning can be valuable without being necessary for every subsequent edit.

A successful build doesn't mean a feature works.

For web changes, I use Cursor's [built-in browser tools](https://cursor.com/docs/agent/tools/browser) to have the agent interact with the running site. It should click buttons, enter text, submit forms, follow flows across screens, and test empty or error states when relevant. For visual changes, I want desktop and mobile-sized layouts checked.

*Here, the agent is testing the search functionality on my blog through the browser, rather than just assuming the code works.*

I can sign into a website myself and then let the agent continue working in that authenticated browser session. If a test fails, it can investigate, make a correction, and test again.

For mobile development, I use [mobile-mcp](https://github.com/mobile-next/mobile-mcp). It lets agents interact with iOS simulators, Android emulators, and even my physical phone. They can navigate screens, tap controls, and type into the running app.

The principle is the same everywhere: **verify the experience, not just the source code**.

The [Model Context Protocol (MCP)](https://cursor.com/docs/mcp) has been another big part of my workflow. Rather than constantly copying details between an IDE and external dashboards, I can give agents access to tools that interact with those services.

For example, I use integrations for Stripe and Firebase when working on features that involve those platforms. For WordPress, I use an MCP adapter connected to my site, allowing the agent to discover and use the operations exposed by the server.

Having access to a tool isn't blanket authorization for the agent to do anything it wants. The task still determines what I want investigated or changed.

I've given my agents SSH and browser-based access to my Proxmox infrastructure. Instead of manually performing every installation and configuration step, I can describe the end state, review a plan, and let an agent do much of the work.

I've recently used this approach to spin up self-hosted applications such as [Paperless-ngx](https://docs.paperless-ngx.com/) and [Warracker](https://warracker.com/) in new LXC containers.

Even here, **I start in Plan Mode**. Before changing infrastructure, the agent proposes the container setup and deployment approach. I review that, make corrections where necessary, and only then let it proceed over SSH and in the browser.

It's made expanding my homelab dramatically easier. I already use Proxmox for other services, including [my Immich photo backup setup](https://www.techopt.io/servers-networking/my-icloud-photos-alternative-setting-up-immich-on-proxmox), and starting another self-hosted app no longer feels like a project in itself.

I also use agents to brainstorm and implement ideas for Home Assistant, from new automations to improvements to existing ones. I've written about [Home Assistant low-battery notifications](https://www.techopt.io/smart-home/creating-a-low-battery-notification-in-home-assistant), for example. AI makes it much easier to move from "What else could I automate?" to an actual implementation plan.

I use the browser tools for the AWS infrastructure behind TechOpt, too. For instance, I can ask an agent to examine CloudFront configuration in the AWS console and review how it's used in the codebase to identify potential cost savings.

*An agent inspecting my AWS CloudFront distributions and investigating ways to reduce costs.*

That doesn't mean the agent automatically gets to apply every suggestion. I still decide which changes make sense. But it's useful to have code, infrastructure, and service management available from the same workflow.

As impressed as I am by the tools, the costs have become increasingly frustrating.

I previously had genuinely unlimited usage in Cursor. That changed, along with the way Auto usage is priced. I'm still on the **legacy Ultra plan at $200 USD per month**, with included allowances for Cursor models and third-party models such as Claude Opus.

The newer **X Subscription Ultra** is a different offering despite its $200 USD monthly price. As described in [Cursor's legacy plan comparison](https://cursor.com/docs/account/pricing/legacy-cursor-plans), it has included Cursor/Grok usage but doesn't include a separate third-party model allowance. Models such as Opus are billed separately at API prices from the first request.

I've exhausted my legacy Ultra plan's included usage several times. At a monthly price approaching **$300 CAD**, that's not a particularly enjoyable experience.

These plan details are a snapshot of the offerings described when I wrote this in November 2026. They may change, but the underlying issue remains: running coding agents constantly can get expensive, especially when several of them are working in parallel.

My main cost-saving habit is simple: don't use the most expensive model when a cheaper one can do the job.

I estimate that **Grok handles more than 90% of my tasks**. I used to rely on Composer as my default, but Grok has become capable enough for most day-to-day implementations.

For complicated plans, demanding changes, or tough bugs, I'll switch to Claude Opus. Sometimes Opus helps build the plan, and Grok implements it once I've approved the approach.

*My usual Grok settings: Fast disabled, reasoning effort set to High.*

One important distinction: **Fast and reasoning effort are separate controls**. I leave Grok's Fast speed tier off because it costs more, while keeping effort at High. Reducing effort to Medium or Low can reduce reasoning-token consumption, but I generally prefer the results I get with High.

I'm not trying to minimize the price of every request. If a stronger model solves a problem correctly the first time, it may cost less overall than several failed attempts with a cheaper one.

With agents producing so much implementation code, I now spend more time reviewing plans and diffs than writing functions.

Breaking large features into smaller issues helps a lot. I can review a focused PR rather than trying to understand a massive change that touches half the application. I look for unexpected edits, missed edge cases, unnecessary complexity, and implementations that technically work but solve the wrong problem.

And now even code review is becoming agent-driven.

I can have one agent implement something and another review it for bugs or problems with the original plan. The implementing agent addresses that feedback, then the reviewer looks again. Iterative review loops can catch issues before I inspect the final diff myself.

**I still make the final call.** An agent being happy with another agent's code doesn't automatically mean it's safe or correct. Questions aren't permission to implement, and implementation isn't permission to commit or deploy. I use explicit rules and skills for those boundaries, including what the agent needs to verify before shipping.

The bottleneck has shifted from how quickly I can type to how effectively I can direct, review, and integrate the work.

I've been programming for **more than 15 years**. I learned to build systems and debug problems long before agents could do these things for me.

That experience is a big reason this workflow is effective. When an agent proposes an architecture, rewrites a query, or changes a complex component, I can usually tell whether the approach makes sense. I'm not just approving an impressive-looking diff.

I do wonder what this means for someone learning programming in school today. If an agent can complete an assignment, how do you build the instincts to spot a bad implementation or question a flawed assumption? What happens when the agent is wrong and you don't yet have the experience to recognize it?

On the other hand, these tools can be incredible teachers. A student can ask for explanations, compare alternatives, trace bugs, and get immediate feedback. Maybe people will learn differently rather than less.

I don't have a definitive answer. But I suspect **learning to evaluate AI-generated code will become as important as learning to prompt an agent to write it**.

The improvement in coding agents throughout 2026 has been remarkable. More of the tasks I once reserved for premium models are now within reach of cheaper ones, and I don't expect the models or development clients I use today to remain my defaults forever.

What excites me most is the speed. I can take an idea to working software incredibly quickly, work on multiple projects at once, and spend more of my time on decisions rather than mechanical implementation.

I'm not saying everyone should stop writing code by hand. I'm describing where my own work has ended up, and why I find it exciting.

I write less code than ever. I'm building at a pace I wouldn't have imagined a few years ago. And I don't feel like I'm doing any less engineering.

*Originally published on [TechOpt.io](https://www.techopt.io/programming/ai-first-development-why-i-dont-write-code-anymore).*
