Lately I’ve been experimenting with AI-assisted coding. I used Cursor to build this blog, and honestly? I barely wrote any code myself!

What the hell is Agentic Coding?

Agentic coding (now colloquially known as ‘Vibe coding’) is quite simply the act of using AI-enabled code-editors to write your code.

For it to be properly “vibe coding” you should be writing most of your code via the AI rather than manually writing it yourself like a chump.

Your job is no longer writing the code itself, it’s architecting the project and ensuring a quality output, congratulations, you just got promoted to a technical product owner!

Isn’t this a bad idea?

In the wrong hands, heck yes. It’s a terrible idea. There is a worrying trend that is popping up that thanks to AI, anyone can be a coder now. However this isn’t true (at least not yet), as the AI can write the code but it can’t actually understand it.

Think of Agentic AI as the same sort of paradigm shift as the invention of the calculator. Sure, now anyone can take big numbers and add them together and get the right answer but a calculator won’t mean you suddenly know differential equations, nor will it make you capable of graduating from Oxford with a maths degree.

AI is the same thing, thanks to AI, you no longer need to write (much) code. The IDE can do this for you and for the most part, it’s fantastic at doing so but it fails in a few key areas:

• It can’t handle a lot of context at once meaning trying to get it to parse a large codebase is tricky at best
• It forgets things a lot, so you can get it to do something in one area and it will implement it entirely differently in others
• It’s based on data it has scraped from the internet, at the time it was trained, this can mean that the code it produces is months - if not years out of date (there are tools such as RAG that help with this and most AI’s adopt this sort of thing but it’s not fool proof and often it will still default to its training data)
• It can easily get stuck in a loop, where it fixes a bug and then causes another one so it fixes that bug which recreates the original bug and around and around we go.

This isn’t even close to an exhaustive list of issues either, there are many times where a developer needs to take the wheel - or at least offer some guidance. If you are not already an experienced software engineer, you ARE going to run into these issues and the scary part is, you may not even realise you have done.

Not all errors cause errors

That probably sounds like nonsense to a non-developer but it’s a truism that all experienced devs know far too well, if something has gone wrong somewhere, a non-developer would expect to see an error telling you that something has gone wrong. The trouble is, that’s not always a thing, let me give you an example:

Whilst I was creating my blog, I asked Cursor to apply placeholder blurring to the next/image instances to improve loading times and preventing page jumps when the image loads in.

It struggled with this quite a bit and I had to let it know that it needed to take the correct metadata from the Sanity query. That’s fine, it didn’t know to do that and if I’d been writing this myself, I’d have hit the same issue without a good Google search.

The trouble is, it applied that functionality perfectly except for in one small place where it had not applied the correct metadata and was defaulting to an ‘empty’ placeholder. That’s still technically fine but was not the desired outcome.

There’s no error message as it’s not technically an error, thankfully, I’ve been doing this job a LONG time and I knew that before I could consider this ‘done’, I needed to go into my browsers inspector tool, turn the cache off and throttle the network speed so I could watch my images load in. If I didn’t know to do that, I’d have never known that the blur wasn’t being applied.

Hell, if I wasn’t experienced in my job, I’d have never known to apply the blur in the first place and this brings me to the next point.

Coding ≠ engineering

Coding is simply the act of writing some code. Go to a text editor and type:

echo "hello world";

Congratulations! You are a coder! It may seem glib but honestly, being a coder is now incredibly easy. This is the paradigm shift that AI has caused, if you really know what you are doing, you don't really need to write your own code anymore.

Engineering on the other hand is the act of taking a set of requirements and working out the best way to achieve those requirements using the best tools available for the job and learning when it’s ok to cut-corners and when to apply the extra polish.

AI is superb at the coding part but it’s still not great at the engineering part yet, so an experienced engineer still needs to hold its hand a lot.

As pretentious as it sounds, engineering is as much an art as it is a science and that nuance is where AI can often struggle.

So why do I use agentic coding?

Because I know what I’m doing, I’ve been in this industry for nearly 30 years and I know how to dodge the pitfalls, I know what the best practices are, I know how to architect a good project and - most importantly - I know what good and bad code looks like. I can spot it a mile off.

For me, AI is a turbocharger. It speeds me up massively. But if you’re not confident in your own skills, it’s just as likely to lead you into a ditch.

How can I improve my own agentic coding?

Depends where you’re at.

I’m brand new to coding

Honestly - and I’m sorry, you won’t like this answer - don’t use it yet. At least, don’t use it to do the big stuff, by all means knock out a few small functions and components but ONLY ever use it to write stuff you already know yourself.

Go and read up on how to write good code, how to architect a good product and most importantly, learn as much as you can about the four pillars of a great modern website:

• Accessibility
• Usability
• Performance
• Scalability

If you don’t understand those things, you will not know when you are producing rubbish.

A few great books I can recommend on the topic are:

• The Pragmatic Programmer
• The Clean Coder
• Don’t Make me think
• The Accessibility Handbook
• Accessibility for Everyone
• Web performance in action: Building faster web pages
• Art of Scalability, The: Scalable Web Architecture, Processes, and Organizations for the Modern Enterprise

Fair warning: I’m old, and these books might be too. But they’ve served me well and their lessons still hold up. You could also just find a good online course instead. Do what you like, I’m not your dad.

And read the next section too. The tips there are useful to anyone.

I know what I’m doing

Then I’d say don’t worry about it too much, you’ll find your footing. Here are are a few sensible tips to make your life easier:

Give the IDE rules and guardrails.

If you’re using Cursor or Windsurf, you can add a .cursorrules or .windsurfrules file to define how the AI behaves.

These rules are project-based but you can also usually add global rules in the IDE settings.

A good set of global rules would be stuff like:

• Treat the human developer as the expert
• Always favour a simple solution over a complex one.
• Tell me your plan in plain English first and only execute your plan when I give you permission
• Never delete anything from a database, provide me the commands I will do it manually
• Never add new dependencies as a first option, if you can do something simple with native code or an existing dependency, please use that first.
• Try to follow the DRY and KISS principles wherever possible, only breaking those rules when it makes sense to do so.
• Don’t add excessive comments and never add comments that wouldn’t make sense in production code (e.g. //we added this line)
• Never use emoji in code comments
• Do not go off-script, only make the changes that were requested of you

For project-specific rules, there is an excellent repository of existing rules that you can use here: https://github.com/PatrickJS/awesome-cursorrules?tab=readme-ov-file

(Don’t worry that they are called .cursorrules, they will work in any agentic IDE, you just may need to change the filename)

You can also ask it to give you multiple plans instead of just one and then you can choose the one to implement. I often don’t bother with this rule as the rules above seem to suffice for me but your milage may vary.

Commit to git after every success

Sometimes, you’ll get the result you want and then when you go to fix the next thing, the AI will screw up the previous result, whilst asking it to rollback its changes often works, it doesn’t always, so it’s good to get into the practice of committing after every successful outcome, just to be safe.

Kill the chat after every success or after a lot of failure

A long AI chat has a lot of context it needs to process, this can be helpful sometimes but it can often just confuse it and will result in failures or it going around in circles. It’s best to get into the habit of closing the chat window for each new thing you are trying to do and if it does start to struggle, just close it anyway. A new chat will often be more helpful.

Extra tip: You can tell the AI you are about to close the chat and start a new one and you can ask it to provide a contextual summary for its successor. This can often make the new chat a bit more efficient - although you may need to tweak the output a little.

Keep it simple

In the same way that functional programming is often good practice, it’s a good idea to practice ‘functional prompting’, don’t go and ask the Agent to do too much at once, focus on a single feature or fix at a time

Test everything!

A good rule of thumb is to write the tests first and then get the agent to make the tests pass, after every change, run the tests again.

Also manually test everything, consider yourself as the QA and consider all possible issues and regressions before determining that the work is successful.

Nudge it when needed

Sometimes, it will just not have quite enough context to solve a problem, in those instances, you can give it hints (e.g. “Have you take a look at these docs, here’s the link…”) or outright tell it to follow a specific path.

Use more than one AI

Technically, I used three AI tools for my blog project

• ChatGPT was my co-architect/product-owner. I’d run ideas past it and asked what it thought and if it saw any flaws in my logic.
• Cursor (In ‘auto’ model mode but usually using Claude Sonnet 3.7) was my pair-programmer, it would do the vast majority of the coding part and was my main point of contact.
• CoPilot in GitHub was my PR reviewer - it would sometimes spot minor issues in the code but for the most part was just there to sense-check things.

One area that I did find useful was that occasionally, Cursor would struggle with something, so I’d hand that over to ChatGPT. None of the AI’s are flawless but you can use them to check each others work and that often gives better results.

The golden rule

Keep an eye on it. You are still ultimately responsible for the output of the AI so don’t just blindly leave it to go off and do its thing as tempting as that may seem. Check its work constantly, watch it when you give it a big job to ensure that it’s not going off-piste or ignoring the rules you’ve given it (which it does with concerning regularity). You should know what good code looks like, so ensure that is what it is producing.

Pandora’s box is open

Look, I get it, this is a scary new world and I have seen a lot of developers express fear that their career is doomed and - for some developers, I’m afraid that might be true.

Hell, on a long enough timeline - almost everyone on the planet will be out of a job sooner or later - AI is only going to keep advancing and robotics is improving at a breakneck speed. It’s likely that by 2035, only human-centric jobs will be left and even they will be a niche.

There is no point in worrying about this yet though. If you maintain an engineering and product-focused mindset, then you will still have a job, it’s just going to get a lot easier.

For those of you who live for the code more than - or as much as - creating a great product then - yeah, sorry, your world has changed for the worse. We’ve all been through it; I’ve always had a massive love for crafting perfect CSS but then Tailwind came along and ruined that for me and now AI is here and can write really good CSS faster than I ever could.

So yeah, I get it but there’s no use in complaining, the genie is never going back into the bottle as the insane productivity gains WILL cause AI to be the dominant producer of code going forward but honestly, you’ve still got a job for the near future, so I say make hay whilst the sun is shining.