DEV Community: Mark Abrahams

Seven Wonders of Agentic Coding

Mark Abrahams — Sat, 14 Mar 2026 13:04:21 +0000

“Man’s desire to build something that will outlast him is the true wonder behind every wonder" — Anonymous

There’s a famous scene in Fawlty Towers where Basil Fawlty’s car refuses to start. At first he employs standard practice in such a situation: turn the key, turn it again. And again. He offers some semi-optimistic motivational talk to his machine: "Come on...", "Start!", and soon escalates his managerial intensity to shouting and cursing at his metal companion. But the car simply won't start. Eventually the relationship breaks down completely as Basil counts to three, climbs out of the car, slams the door, delivers a stern lecture about unacceptable performance, and finally procures a nearby tree branch and begins beating the car with it.

If I Just Prompt Harder...

Which brings me to AI coding agents.

Let me begin by saying: They're Absolute Magic most of the time!

There are rare occasions in development that I've hand-written more than 100 lines of code (yeah—I remember those days of hand-written code like it was only last year! 😄), and the code just worked first time. Almost always, the next step after a big code dump was a big fix-up session to iron out all of the unintentional stupid. But I do remember one time being completely shocked at two pages of untested new code (with a number of indents!) working first time. I elatedly and desperately tried to tell the nearest person what an amazingly rare and beautiful thing that really was, and, like Halley's Comet, this might not come around again for years. My then 8-year-old daughter didn't share any sense of the occasion.

But for the latest agents, that's just Tuesday. I've observed I think around November/December 2025, that coding agents had gotten noticeably better at getting large amounts of code working first time—certainly waaayy better than me at this! But there's still that one time...it just can't get it right! Prompt after prompt after prompt to "Still not working" to "Try this..." to "No I've already given you the output that shows that cannot be the problem - please remember this" to "Write up an assessment of the problem, and why you keep getting it wrong and your best assessment of the underlying root cause" to "THIS IS NOT ROCKET SCIENCE!!" to reaching for a nearby tree branch...

The Struggle Is Real

There are still some—increasingly rare—times when I could fix or implement something by hand quicker and better than an AI. Not many, but still some! And yet why wouldn't the agent struggle? It's surprising it doesn't struggle more often! It didn't have my tools—my browser access, my DB access, my log access. It was flying blind. I was expecting something I wouldn't expect of myself.

Peak Coding Agent: Confidence in the Face of Facts

As an aside, I've noticed an interesting phenomenon in my psychology that I tend to develop a growing stubbornness to "manually" fix a bug myself the more an AI has failed. If I Just Prompt Harder™. Also, a little worryingly, I'm growing a reluctance to have to shift my brain from "code orchestrator" to "code writer" mode. It seems like such an inefficient context switch, when I was progressing the app so much quicker as Chief Orchestration Officer than as Code Monkey With Typewriter.

Giving Agency to Agents

And yet we know that the coding agents we use are incredibly capable. After sustaining a sufficient quota of battle scars, I started to think about better solutions. The core issue wasn't agent stupidity—it’s that the agent doesn’t natively have access to the same tools we have as developers. The all-powerful genie was squarely bottled. So I started to think about the tools I had to use to fix stuff―DB clients, the browser console, log files, and access to the rest of the development stack.

So I remember the day that I stopped mid-problem-going-nowhere (very difficult for someone who thrives on closure!) and started to research how to give the agent access to these sorts of tools. Make it their problem.

I'm not a natural salesman, so without wanting to oversell an "and I got a 10x boost in productivity", I can genuinely say I did get some profound "wow" moments along the way. The agent started to self-evaluate solutions, realize it was wrong, iterate, re-test, and keep doing all this until it could prove its solution actually worked. Yes, it costs more tokens. But “please try again” fifteen times isn’t exactly cheap either—and it’s considerably worse for the soul.

So, with an agent now armed with a suite of tools that gave it developer-level visibility to the local dev stack, results were pleasing—I would say inspiring even! Inspiring enough for me to...yeah that's right, write a blog post about it!

Renewed Sense of AI Progress

This lifted my AI coding experience from the very human-in-the-loop approach that hadn't really changed for a year, to a much more—yes—autonomous—agent experience. Fix this, here are the tools, make sure your fix works, don't come back to me till you're done. Motivation and psychology are an incredibly important part of life, and this had the strongly motivating benefit of making me feel like I was actually "keeping up with AI" - whatever that meant in my troubled mind!

And so I pledge to you a 7-part series that will shed light on what I've configured for my coding agent and what effect it has had. I call the series, based mainly on the specific number of these, the Seven Wonders of Agentic Coding.

I really should have led this article with: "I gave 7 tools to my agent and got 100x productivity". But no that didn't happen. It did, however, make a noticeable difference:

Velocity: certainly something of a development speed increase as the agent did things that I was doing manually―it was just faster!
Sanity: significant frustration decrease
Focus: less involvement in the weeds as the agent did more weeding―meaning less context switching from high-level to low-level affairs
Confidence: most satisfyingly, I'd lost the feeling that I'd fallen off the AI coding train that everyone else seemed to be riding so easily and successfully

I don't have a swarm of 100 agents. I'm not a 100x developer. But I do have a pretty powered up agent that can battle the world for me for long periods. This Is Much Better™. I mean much better than what I had before. Not better than the 100-agent swarm―I mean who wouldn't want a 100-agent swarm, right?

How much will this series move the needle for your agentic development? I'm hoping lots―it did for me! And that is my aspiration for you too―may it be supremely useful. Agentic coding eh―what a wild ride! O where will it end?!? Far from here―but exactly where...I'm not sure!

Ending the Beginning - Oppa Churchill Style

It's Hype 'Cause it's a Step Change

Mark Abrahams — Sat, 07 Mar 2026 03:05:02 +0000

“There are decades where nothing happens; and there are weeks where decades happen.”— Vladimir Lenin

AI – wow!

Just Google It

I can recall precisely two times in almost 3 decades of technology work where I’ve experienced a step-change in my work process. There have been plenty that I would class as incrementally good changes, but only two with enough magnitude to sit back and marvel at life pre-change vs life post-change.

The first was in 1999. It was also my first year of IT employment. That year that gave us the first installment of The Matrix; the Melissa virus hit IT departments with its macro-into-word-template payload. Half the year was spent changing computer clocks and running Y2K-readiness tests. And it was also the year I discovered Google search.

Young people might not understand that pre-Google Internet life was pretty rough: there were plenty of search engine options, but the typical experience was:

wading through duplicates,
dead links,
next page, next page, next page
until finally you got something of some use.

With the new Google search engine, you could just Find What You Want (TM). A 15-minute search exercise became a 15-second search exercise. It felt like a step change.

In between times technology marched on: faster hardware, better IDEs, hosted infrastructure, better version control, better package managers, new programming languages. Yep, lots of valuable improvements, but they all seemed incremental, rather than a sudden difference. (Yes iPhone-like mobile was huge culturally, but didn't really shift the work needle for my particular job.)

Just ChatGPT It

And so it remained. Until early 2023. As the world recovered from the disruption of the global pandemic, a new chat service was taking the tech world by storm. My first test of ChatGPT was to give it what I'd also considered an arduous task of writing an information privacy policy document. I don't do policy documents much, and so when the "opportunity" comes around, I'm neither well-practised nor well-enthused for the task. In loading up a couple of sentence prompt, and seeing hours of work unfold before me in a matter of seconds, this felt utterly magical. AI - wow! It's finally arrived! And with it, my second step-change: You can just Create What You Want (TM). I'd appreciated incremental improvements in machine learning applications over the years, but this generative AI was a huge. Generating, creating documents, code, tests, diagrams. I branched out to songs, videos - it could do it all. Wow!

If you asked my kids or colleagues, they'd probably say I've deep-ended a bit with AI. The monologues are real. If AI was a 90s hip-hop act, I'd probably have a big clock around my neck and a name like Flava Flav.

Yo Chuck Imma generate yo some AI

Step Changes Throughout the Ages

I wonder if our forebears had similar vibes? Imagine receiving your first printing press after a life of handcopying - being able to produce 3,000 pages in a day's work instead of 30. What a step change! Imagine the postie who trades in his horse for a new government-issued motorcar—how gangsta would you feel being the mailman that delivers—fast and with style in your new automobile?!?

While there are professions such as the blacksmith that became obsolete over time, many would have just changed with the tech. That copyist-cum-printer would have increased the scope of what he could take on. The postie adds another delivery route to his schedule. Generative AI feels to me like a force-multiplier for a knowledge worker's tasks. I'm more in the amazing-leverage category than the impending-obsolescence category here. Throughout the history of technological advances, we humans tend to move to higher-level and more interesting tasks, rather than sit around en masse twiddling our thumbs because the technology has taken over.

The LLM Revolution

Stating the obvious, it's the production of large volumes of stuff quickly that's the wow factor here. And that stuff—even from the outset—has been anything from adequate to outstanding. So my intervention in the creation process is anything from "minimal" to "well I would have had to spend lots of time on it anyway".

Using generative for the first time in new ways makes you feel like a tech gangsta. Here are a few areas where it's already a been a bit of a force-multiplier for me:

Document summarisation - LLMs shine here. When I wrote a very simple "summarize the bill before the NZ parliament" prompt for my Democrify app, the one-pagers were incredibly useful in maximizing the knowledge-gained-to-time-spent-gaining-it ratio.
App production - AI coding agents have enabled me to give birth to or revive projects like Democrify and DefProd that I couldn't have sustained without. The shift from code writer to orchestrator is real for me. There's more "conducting" of AI agents and systems going on. The way I develop software today has changed markedly from a year ago. And a year from today, I'm sure I'll say the same thing again.
Code Testing - My open source library node-net-snmp was light on tests until AI gave them a big shot in the arm. It's now adequate on tests :-)
Documentation Creation - Documentation and software developers go together like diets and dessert. I fill my repos now with AI-produced markdowns and designs. I like to implement with an AI agent, and then end a chat with instructions to summarize the new feature into a document for permanent record. It helps me; it helps them.
Architecture Discussions / Debates - I tend to tire out my colleague with stuff that's important to me and me alone, but LLMs just dive with you right down into that rabbit hole that nobody else cares about - and keep going! It's invigorating!
Writing Tools - I've long written small bash scripts or Node.js utility tools for certain functions. AI can knock these out with ease! I've even posted about a couple of these: MCP Client REPL and llmshot.
Vocal Production - Audio models have produced for me vocals passages that I just couldn't pull off myself - when it comes to African-American preacher "sampling" or low-intensity growls (Phoenix Rise), or choir effects (The Day The Thunder Roared), it's just better than me. It just is.
Video Production - I started producing music videos for the above songs. OK, gotta be honest here, I tried that about 6 months ago, and that was my biggest AI fail. Not to say that it was awful, just that I spent a lot of time trying to prompt my way to character continuity, camera instructions, etc. in about 4 or 5 different tools, and made limited progress. I got some very cool isolated shots, but couldn't stitch together anything coherent enough. Who knows, six months on, this may have all changed!
Blog Posts - Ha! No I've decided I'm not too much a fan of the common LLM-produced article style, so while producing entire blog posts with AI is alluring, it's not really either (a) what I want to say or (b) how I want to say it. And we need good content authors to write well for the LLMs of the future as well as humans! (I'll come back to that in a future post.) Proof-reading, quote ideas and image generation though—I do open the AI door on some blog things! And I love em-dashes...
Checklists / Plans - Charged with feeding the family for a long-weekend music festival, I threw an MCP server at Google Sheets and an AI agent created the entire meal plan and grocery shopping list. Honestly, without my wife to organize things, it saved the rest of the family from a weekend of forced fasting—food ain't my forte, but we dined like 17th-century kings!

And yet there are still 2 r's in "strawberry" (GPT-5.2—just yesterday!) It still amazes me the capacity for LLMs to do extraordinary things, but at times botch the basics.

But What About My Job?!?

Two good questions to ask:

"What of your profession can AI do well?", and

"What parts of your profession are human effort and input still valuable?"

The gap that AI can't do so well at (yet!) - that's your opportunity!

And I think the opportunity is huge at the moment, and while it will change in nature over time, and vary per-industry, I think significant opportunity to apply AI well to your profession will remain for some time. In the years at least. But advantage is shifting rapidly to those finding ways to apply AI tools to their craft.

That said, I can identify with anyone feeling overwhelmed in the midst of the AI hype. I was recently reading how this guy gave vague instructions to his AI agent army, came back a day later to a fully-built app. Another guy is so engaged he gets out his phone at a restaurants and gets his remote agents to code up features between bites. And the other guy that got his Openclaw instance to code up a trading bot, make $10,000, and book him a trip to the Bahamas with the profits, all while he slept! OK, I made that last one up. But the first two were from actual social media posts. They may also be true.

I've found it really easy to feel utterly left behind on this stuff. I deal with this sentiment by just making small, regular discoveries, doing tests, downloading AI tools or even writing them—with AI help! Or posting about them! Making steady progress is all you can really commit to. I'm not running 100 agents writing software in my sleep. Yet.

Generative AI is a step-change, and these technology moments are rare. You might get two or three in your lifetime. If you're here reading this: This is your moment! Think "opportunity" and dive in!

We believe this to be a simple spelling error

If you feel like you're overwhelmed in the deluge, start small. It might be to install an AI coding agent (e.g. cursor, Open Code), or run up ollama with a local model, or sign up for an AI API key of your chosing, or write a small MCP server, or a simple agent loop, or slide AI into a regular process where it might help. The great thing is—you can just ask an LLM how to do any of that stuff as well, so it doesn't have to be a lengthy solo struggle (in most cases anyway!)

Concerned, Excited, or a Bit of Both?

There are a number of concerns about the generative AI wave we ride—we've all had discussions and scrolled social media enough to know about these. And they're valid. Workforce obsolescence, energy consumption, AI responsibility/safety, prevention of Skynet—all issues that we're rightfully wrestling with.

But that's for another day and another post. Because today, I'm taking another moment to take a step back, see the step change, and say again:

AI, wow!

Give LLMs a Shot

Mark Abrahams — Sun, 22 Feb 2026 08:17:16 +0000

"Brevity is the soul of wit" - William Shakespeare, Hamlet

Originally published at: https://theunsuredeveloper.com/give-llms-a-shot

"I'm temporarily departing this establishment in order to acquire a more suitably reinforced transportation vehicle capable of facilitating my immediate objective of re-entry through your currently locked access point, at which time I will resume this interaction with considerably greater efficacy and substantially reduced regard for architectural barriers, so you may wish to interpret this announcement not as a polite farewell but as both a menacing and statistically reliable guarantee of my imminent and forceful return"

is what Arnold Schwarzenegger could have said to the desk sergeant, but thankfully he spared us the diatribe and left us with one of the most memorable quotes in movie history:

T-800 - Terminator 2: Judgment Day

Great one-liners tend to stick with us. They're short. They're sharp. They achieve a precise purpose.

In software, I love one-liners!

they're brief to remember and type
they're often composable
they can encode so much into so little

The last one is important to me. I don't have to think about anything more than I would actually like to think about in running my one-liners. Even if the one-line script is indeed a one-line command itself, I'll often prefer it, as it captures my defaults, my processes, my standards.

And for this reason, I find myself writing small bash or Node.js commands all the time.

Today's one-liner was llmshot. It's a bash command that simply calls an LLM and returns a response.

It's available for free under the MIT license at:

GitHub: https://github.com/markabrahams/llmshot

The Power of a One-Liner

The longevity of Unix has always been a wonder to me - how on earth is most of the world still running on an OS design born in the 1960's?!? In technology that's the closest thing to eternity that you'll get. My conclusion: They must have done something incredibly right. Probably a few things actually! But the right-est thing about Unix is the Unix Philosophy:

Do One Thing Well.

Small, focused, composable tools—designed to be chained together with pipes—have powered decades of automation, system administration, and development workflows. They don't try to be everything; they just do their job well. And because they're simple, they're easy to embed in scripts, CI pipelines, cron jobs, and larger systems.

Consider:

grep -r "TODO" .

awk -F, '{sum+=$3} END {print sum}' file.csv

curl https://api.example.com | jq '.data[].name'

Each of these tools reflects the Unix philosophy. They're doing one thing. And they're doing it well.

Bringing LLMs Into the Unix Tradition

Large Language Models are powerful. But they often come wrapped in:

Web interfaces (and evil silos at that! More on this later...)
SDKs
Full application frameworks
Streaming APIs
Complex setup

What if you just want to:

Ask a model a question
Summarize some text
Generate a commit message
Add intelligence to a script

In one line? There's an app for that!

What Is llmshot?

llmshot is a lightweight bash-based CLI tool that lets you call LLM providers with a single command.

It supports multiple providers (including OpenAI, Google Gemini, Anthropic, and local Ollama instances) and relies only on tools that already exist in most Unix-like environments:

bash
curl
jq

No Node or Python. Light on dependencies and runtime bloat. Just a simple command that sends a prompt and returns a response.

Simple example:

llmshot -p openai -t "Give me a clever anagram"

Or piping input:

cat article.txt | llmshot -p google -t "Summarize this text:"

That's it!

What's Cool About That?

The magic of Unix isn't individual tools—it's composition.

Consider this:

git diff HEAD~1 | llmshot -p openai -t "Summarize these changes:"

You've just built an AI-powered commit summarizer.

Or:

journalctl -n 200 | llmshot -p anthropic -t "Identify anomalies in these logs:"

Now you've got AI-assisted log analysis.

Or:

find . -name "*.md" -exec cat {} \; \
  | llmshot -p ollama -t "Generate a project overview from these documents:"

Instant documentation synthesis.

What I'm saying is this:

When an LLM becomes a command-line primitive, it becomes automatable.

It turns AI from a chat window into easy-access infrastructure.

The Unix Philosophy, Revisited

Douglas McIlroy, one of the pioneers of Unix, summarized it like this:

Write programs that do one thing and do it well.
Write programs to work together.
Write programs to handle text streams, because that is a universal interface.

llmshot aims to fit this philosophy:

It does one thing: send prompts to LLMs and return responses.
It works with other programs via stdin/stdout.
It treats text as the universal interface.

It doesn't try to manage conversations—no history support. Also, no streaming responses—as such, you can be waiting an uncomfortable amount of time for the final response!

It's a minimal but sharp tool.

Your Automation is Your Leverage

Once LLM access is reduced to a one-liner, entirely new possibilities open up:

Pre-commit hooks that auto-suggest better messages
CI pipelines that summarize test failures
Cron jobs that digest daily logs
Scripts that transform raw data into readable reports
Static site generators enhanced with AI commentary
Trading systems that annotate strategy output (yes, really)

A little AI can go a long way!

Turn any shell pipeline into an LLM-enhanced pipeline.

A Good One-Liner Is Power

Movie one-liners endure because they compress power into a small space. Great Unix commands endure for the same reason. llmshot brings that spirit into the LLM era.

One line. One prompt. One response.

Will you weave the power of AI into your CLI?

In the words of Captain Picard on the reception of his Bernina 830:

Jean-Luc Picard - USS Enterprise Captain and budding seamstress