I’ve had a hobby of small programming projects to solve various curiosities I encounter. The ecosystem for such projects has changed dramatically with the introduction of AI coding tools. Outside work,

I’ve experimented most with Github Copilot and Google Antigravity. In particular, I bought the Github Copilot Pro plan ($10/month, $100/year) and have an Alumni student email that gave me Google AI Pro (normally $20/month, $200/year). These plans initially allowed me to code without much constraint but recently both plans tightened up usage restrictions/limits. Copilot now has $10/month of “credits” and if I am not careful, I can run through those credits pretty quickly and have to wait another month. Antigravity has a sustained limit that enforces a five hour timeout and I’ve run into that one more often than their weekly limits. I am still figuring out how to use local LLMs work as effectively but that will be another blog post.

Following are three local projects I was able to code up pretty quickly through the use of my Copilot/Antigravity duo:

• A World Cup Tracker and Simulator – https://github.com/mvermeulen/ai/tree/main/worldcup This one keeps track of the game standings and performs a Monte Carlo simulation to find probabilities of different outcomes by team. For example, the probability of reaching the round of 32 or the final match. I’m not a detailed soccer nerd so I had it import algorithms weighted by ELO ratings, host rankings and then backtested these against previous matches.
• A bicycle tour route evaluator – https://github.com/mvermeulen/g2l4a. This one takes a high level description of a bicycle tour in terms of cities visited and then searches and compares different routes on basis of distance, hills and climate (temperatures). It ties into an Open Street Map service for distances and historical data for temperatures.
• A Collatz computation and search program https://github.com/mvermeulen/ai/tree/main/hailstone. This one takes off to create optimized searches extending from ideas myself and co-author worked on almost 40 years ago.

All three of these started from a high-level interaction to start a project from scratch and then iterative development to add features. Some perceptions I have had in doing these projects:

• Both Copilot and Antigravity are pretty amazing at taking a high-level sometimes fuzzy and implied intent and drafting it into a solid plan. This seems to be a particular strength using their cloud models that I have difficulty doing with local LLMs. Antigravity has an explicit approach where it drafts an “Implementation Plan” and lets you review/modify it. Copilot doesn’t explicitly have this mode but this is a common approach I take – asking first to write an investigation report, then tune the investigation, then write an implementation plan, then turn the implementation and then execute. Even with such explicit steps local LLMs still fall short.
• End to end verification is critical. These tools can confidently create a result that is confidently wrong. For example (a) early versions of the bicycle route program created some routes with horrible inefficient route choices (b) world cup games weren’t getting update properly (c) the search programs needed to be cross checked. When these happen, I both have the AI tool debug the issue and also write some additional testing to verify that it continues to work. For the Collatz calculation I had it develop three implementations – cross check results and also compare against the external page of results. For the World Cup, I look at the results presented and verify the correct teams are recorded, etc. I have seen enough that I wouldn’t trust these agents without strong verification or something I couldn’t try the smell test.
• Incremental development works well. I don’t have all the features in mind up front. Instead, I let the program develop the first set, then play/verify with them and then pick the next set. That requires multiple rounds and multiple conversations (and these tokens that run out see above). It is essentially a different method of programming.
• AI tools are pretty good at finding/summarizing higher level descriptions. A good example is an optimization of Collatz calculation I worked through with Antigravity: https://github.com/mvermeulen/ai/blob/main/hailstone/doc/fpoly_apriori_cutoffs_investigation.md This is one worked step by step – and then asked to have it documented more completely to record logic behind it. It took my solving the problem to discover the approach but Antigravity was good at summarizing at a higher level. Similarly the documentation of these programs came from higher level asks like “is the documentation up to date”. They are also pretty good at coding paradigms I don’t inherently know. It would have taken me much longer to code the Vulkan and ROCm backend specific versions of Collatz calculation.

Overall, definitely a different skill and a different way of programming – but still enjoyable in a creation sense of programming and lets me create things that otherwise would have taken much longer. These three projects are all ones I’ve taken to a level of being useful – but I also have some others I previously worked where the AI Tools let me program something that turned out to be too fragile/complex and I ended up abandoning the approach. I got there more quickly than I would have and was then able to create a simpler variation from scratch by starting over – so not all was lost.

There are several areas I am still exploring further but haven’t worked out well enough to summarize a blog, e.g.

• A more explicit structure of instructions with tools like Cline and Claude Code. I’ve seen and read about both tools and had some basic experiments. My general sense is it benefits from more explicit written rules that are developed and expanded as the code develops. A more structured approach than my investigation/plan/implement approach and likely also better with local LLMs.
• Command line driven tools and more explicit use and creation of agents. Tied in with instructions above.
• Pushing further on local LLMs, e.g. using ollama on a Strix Halo laptop with large shared memory. Enabling both offline and private development and getting around those usage limits/costs.

There is a lot to play with and the area has changed rapidly…