Cursor, Grok, and the other agents

A year ago, an AI coding tool was mostly autocomplete with a good attitude. Now I have agents that open the whole project, read how it’s built, make the change, review someone else’s change, and flag the security hole I didn’t notice. Cursor is where most of my code happens. Grok Bot runs alongside me and handles the work around the code. Codex, Claude, Copilot, and a new one every few weeks are all chasing the same thing.

The pace is the part I keep coming back to. These tools aren’t getting better once a year. They’re getting better between my Monday and my Friday. And they’re changing the job itself, not just how fast I type.

The biggest shift is how short the gap is between “I know what I want” and “it’s running.”

I describe a change specifically: what page, what it should match, what it shouldn’t touch. The agent reads the repo, follows the patterns that are already there, and makes the edit. Work I’d have put off until next week happens this afternoon. Boilerplate, migrations, form validation, a new admin screen that looks like the other five: that stuff used to eat days. Now it eats minutes, and I spend my time on the parts that actually need a person.

It changes what a small team, or one person, can take on. Ideas I’d have shelved because there weren’t enough hours are now just a weekend. I’m building side projects next to a full-time job, and that wouldn’t be realistic without this.

Review used to be the bottleneck. Somebody has to read the diff, and that somebody is busy.

Now an agent does the first pass before a human ever looks. It catches the unhandled error, the query that’ll fall over at scale, the function that quietly does something different from its name. It explains a change in plain language, so whoever reviews it after gets context instead of a wall of red and green. By the time I review, the obvious stuff is gone and I’m looking at the decisions that matter.

It also works the other direction. When I’m reading code I didn’t write, like an app I’m converting or a system I inherited, an agent can walk me through how it fits together in a fraction of the time it’d take to trace it by hand.

This is the one I care about most, because security review is the thing that gets skipped when deadlines hit.

An agent will read every input path and ask whether it’s validated. It’ll check for SQL injection, missing CSRF tokens, secrets sitting in a config file in the web root, session handling that doesn’t expire, and a dependency with a known CVE. It doesn’t get tired, it doesn’t skip the boring files, and it doesn’t assume “we’ll fix that later.” I can ask for that review on every change instead of once a quarter.

It doesn’t replace a real security audit. It does mean the baseline goes up for everyone, including solo developers and small shops that were never going to pay for a pen test.

Grok Bot isn’t a coding tool for me. It’s the layer around the work: tracking tasks, drafting the prompt I’ll hand to Cursor, checking email for things that need me, keeping projects organized, and remembering what we decided last week. Agents are starting to plug into everything a developer touches, not just the editor. That’s where I think the next big jump happens: the planning, tracking, and coordination that sits between writing code and shipping it.

I’d be lying if I said it’s all upside.

They’re confidently wrong sometimes. An agent will invent a function, a config option, or a number and present it like a fact. Fast and wrong is still wrong. You have to read what it produced.

Access is a real risk. An agent that can read your repo and run commands can also do damage. I keep them fenced in: this repo, not that one; these files; no live keys; no passwords pasted into a chat to save a round trip. “Helpful” has to come with limits.

Skills can slip. If the agent always writes the query, it’s easy to stop understanding the query. I still write code by hand when I’m learning something or when I already know exactly what I want.

More code means more to own. When producing code gets cheap, you can end up with a lot of it. Somebody still has to maintain it.

None of these are reasons to sit it out. They’re reasons to stay in the loop.

I decide what ships. I read the diff. I run the page. If a change is weird, I throw it out. The agents do the typing, the first review, and the security pass. The judgment is still mine.

That’s the deal I think the industry is landing on: developers spend less time producing code and more time directing, reviewing, and deciding. The developers who get good at that, who learn to give a clear brief and check the work, are going to build things a lot faster than the rest of us thought was possible a couple of years ago.

I’m going to keep building that way. This post included.