Taishi Akamatsu

Did everyone forget that it was just 5 minutes ago that we were still hunting on Stack Overflow for a solution to this one bug we couldn’t solve?? Why can’t we have a more rational view of what remains when you strip away the hype around large language models, agents, and tooling? With the right setup, even cheap or local models make a developer's life so much easier. This week, I worked on the parser for the IntelliJ Wolfram Language plugin. When I started this project in 2012, there wasn't much information about the language, let alone a complete grammar. Most of the knowledge came from scattered documents and lots of discussions with other developers. I knew my implementation was good enough for the plugin, but it still had many quirks and gaps. So I used Wolfram’s CodeParser, an awesome project mainly developed by Connor Gray and Suman Banerjee, as my Ground Truth. I wrote a small adapter for my plugin’s structure and a wrapper around CodeParser's CLI to connect it to my plugin's unit tests. With that in place, I could use CodeParser's many test cases to compare results and identify differences. The agent could then work through the necessary fixes step by step. The Baseline made all the difference. The agent had something concrete to work against, and I could see when it went off track. Now, there are 421 passing unit tests, each checking a specific case against the baseline Wolfram parser. I could have done this manually, but I estimate going through every reported difference and fixing it would have taken me weeks or months. I used OpenCode as an agent inside the IDE through the Air plugin. The model was GPT-6.1 Sol, which is much cheaper than other frontier models like Astra. Reasoning was high for the planning and medium for the implementation and the rest. I made sure the agent knew how to navigate the attached SDK sources, had access to a research subagent to find information about the IntelliJ Platform, and knew how to interact with the IDE to run inspections, reformat, and use all the other MCP tools. The whole thing used around 410 million tokens, of which 400 million were cache reads, and 6.5 million were cache writes (which means they were really cheap). That came to around $70 for my actual usage, which is OK given how much work has been done. For comparison, based on the same token breakdown, I estimate it would have cost roughly $550 with GPT-6 Astra. I’m sure that with smaller steps and maybe more guidance, this could have been done with a local Qwen model. I think a lot of it comes down to knowing your tools. As a developer, you need to understand what you're asking the agent to do, how to give it the right tools, and, most importantly, how to check whether it actually did the right thing (yes, you can and should interrogate your agent about its own work; try it). Otherwise you're just hoping for the best.