The expanding scope of coding agents A software engineer reports that coding agents have graduated from handling individual functions to small, self-contained features, and are now approaching larger artefacts, based on his experience moving from Anthropic's Claude to Z.ai's GLM coding plan and testing OpenAI's Astra model. The engineer said the GLM models were "mostly good enough" but not as capable as the Claude series, while a year-long GLM subscription cost about the same as a month of Claude with higher limits. He added that falling model costs, including a new flash model and token discounts, let him run two to three tasks simultaneously and review only at the end. The expanding scope of coding agents Published on It’s time for another post about LLMs I know, I know, that’s basically all anyone talks about these days. But that sort of makes sense: it’s what a significant number of software engineers spend their day using. And they’re changing so rapidly. Back in May last year, I said https://chameth.com/coming-around-on-llms/ : But how good is it at actually writing code? It’s like having a keen but not particularly thorough Junior Engineer at your beck and call. If you give it a clearly defined task and guidance on how to implement it and maybe some feedback as it suggests changes , it’s more than capable of doing it. If you don’t give it enough guidance it tends to go more off the rails. I tried having it generate a simple application from scratch with minimal technical guidance and no review of what it was doing, and it made such a mess of it I decided it was quicker to throw it away and start again by hand. What I was describing there basically amounted to “the coding agent can be responsible for a function, or a group of functions if they’re described well enough”. That post was published at about the time that Sonnet and Opus 4 were released, and there have been several big releases since then. Graduating from functions to features Now, I didn’t stick with Claude through all those shiny new releases. Anthropic effectively banned using third-party harnesses with their subscription plans, and did it in a way that rubbed me the wrong way. As far as I’m concerned, I’m paying for inference-as-a-service: it shouldn’t matter if I do that via Claude Code, or OpenCode, or something else. But they disagree. So I jumped ship to Z.ai’s GLM coding plan https://z.ai/subscribe . At the time I signed up, the cost for a year-long subscription was about the same as a month of Claude, with higher limits. The GLM models definitely weren’t and still aren’t as good as the Claude series, but they were mostly good enough. But as new models were released, the capabilities slowly ratcheted up. I noticed the unit of work I gave them graduated from functions to small, self-contained features. Instead of describing exact implementation steps, I was describing the functionality I wanted. I didn’t stop providing guidance on how to do it, but I was increasingly happy giving it larger chunks of work and getting something reasonable back. Around the same time, the cost of some of the models dropped quite a bit. Between a new flash model, token discounts, resets, and so on, it got to the point where I couldn’t hit the plan limits even if I tried. So I was throwing more and more work at it: having two to three things going at the same time, with me only dropping in at the end to review and ask for follow-ups. From features to artefacts The GLM models weren’t quite good enough to tackle larger units of work. I tried going back to Claude to see what it was like now but bounced off because its output was incredibly painful to read. I wanted to try Fable, their next-tier model, but you can’t do that without one of the amazingly expensive plans or paying API costs directly. Neither of those options is particularly appealing to me. Meanwhile, OpenAI launched Astra, their Fable-equivalent. And you could use it in small amounts on the less expensive plans. I played around with Astra on a few small things, but I was conscious of the low limits. Plus, GLM-5.3-flash mostly did the bits and pieces that I wanted. I figured I’d give Astra a proper try the next time I had a larger project. Fortunately, some packet loss gave me that opportunity very soon. I use Navidrome https://chameth.com/further-adventures-in-music-organisation/ running on a remote server to host all my music, which is fantastic. Until your connection goes a bit wibbly. Apparently, the music player I was using didn’t believe in buffering, so when I developed 20% packet loss to the server the music kept pausing, playing a second, pausing, playing another second, and so on. Pretty much the most infuriating way it could have handled it. Writing my own music player had been at the back of my mind for a little while, and suddenly I had both impetus AND a shiny new tool. I launched pi https://pi.dev/ , switched over to Astra on low thinking mode, and gave it this prompt: This is a new project. It’s going to be a native music player written in Go using the Gio library, backed by a Navidrome server. Think foobar2000, but Linux-native, Go, and Navidrome. It doesn’t have to do everything right away, but an MVP should be able to: connect to navidrome saving credentials , show playlists, play a playlist in order. skip tracks, pause/unpause, adjust volume, etc. It should be tolerant to network issues – buffer a good few minutes of playback data, or an entire track or two. I have two other UI projects using Gio for reference, see ../gtodo and ../glauncher. For actual playback we may want to consider using an established backend like mpv, but that’s not a hard recommendation. For this project you are the overseer/orchestrator. You should use subagents using the zai/glm-5.3-flash model to do recon, implementation, debugging, etc. You can ask me questions if you have any. I’d seen a few comments from people doing a similar kind of orchestration, and references to tools like prime agent https://github.com/PrimeIntellect-ai/prime-agent that have first-class support for the workflow. It seemed like a natural fit for my case: Astra can do the orchestration, architecture, and review, but the much cheaper GLM models can do the actual heavy lifting. It asked me a few questions, and an hour later a fully functioning music player popped out: It was exactly what I asked for. A one-paragraph prompt producing a fully functioning piece of software kind of blows my mind. And that was with Astra on low thinking, on the £20/month plan, orchestrating cheaper agents. There was a fair bit of judgement encoded in the prompt, and “think foobar2000” carries a lot of information in just two words, but it still felt very light on the details compared to what I’d usually write. Just a description of what I want in, and a binary out. I’ve been using gmusic for a week now, and only had to make a few minor additions to go from “MVP” to “comfortable daily driver”: scrobbling support, media keys, and remembering playback/playlist position across restarts