Project: Sway The People!

Description

Sway The People! is a political simulation game for Linux, Windows and macOS. It is an Electron-based project, written in TypeScript.

I started developing it on July of 2026, and released the 1.0.0 version on August 11th, 2026.

In the game, players run a political campaign for leader of a fictional nation, against 3 other candidates, with events, debates, and public opinion in general being driven by LLM models. The premise of the game is to make the campaign (and the nation itself) as custom as possible, with the player being able to create their own policies and speeches in free text, and everything else in the game adjusting itself to that through generative AI models. While some parts use more traditional evaluation mechanics, the idea is for the bulk of the gameplay to be guided by LLMs.

While I enjoyed playing several campaigns, the game is mostly an exploration of how generative AI, and LLMs in particular, can be embedded in games to enable new experiences.

Context

The development of Sway The People! happened at the convergence of three threads: me experimenting with vibecoding, Anthropic's Fable 5 release and my interest in applying generative AI to games. I will describe each one here.

Vibecoding

After using generative AI for several purposes since early 2023, and starting to use coding agents around 2025, this year I am exploring development flows that use generative AI in even more pervasive forms. One of the furthest down the spectrum (and trendiest one) is vibecoding, in which the developer avoid as much as possible looking at the generated code, and drives the development just by talking with a coding agent and accepting whatever it produces - if something does not seem right, the developer just asks the agent to change it again. For Sway The People!, I decided to try this flow: I focused only on the requirements and the overall vision for the project, while delegating all the code concerns to the agent. I will go into more details about my flow further down in this post, in the highlights section. Suffice to say, I think I was able to achieve the vision I had for the project, but I had to follow a more organized and thoughtful approach than most vibecoder-gurus preach about. Despite the success, I still prefer the AI-assisted Engineering approach, in which coding agents are used to speed up the development, but the developer still remains very involved with the final code.

Fable 5

The second thread was the release of Fable 5. Earlier this year, Anthropic announced it had created a model representing a whole new class of intelligence, called Mythos, which it declined to release to the general public; instead, on June 9th of 2026, it released Fable 5, a version of the same model with additional safety measures. What followed was quite a saga: just three days after launch, the US government put export controls on the model and Anthropic suspended all access to it, only restoring it globally on July 1st. On top of that, Anthropic had said from the start that Fable would only be temporarily included in the usage limits of subscription plans, requiring separately billed usage credits afterwards... but the cutoff date kept getting pushed forward (it moved from June 23rd to July 8th, then July 13th, then July 20th), until Anthropic finally announced, two days before the last deadline, that the model would remain a standard part of the higher subscription tiers indefinitely. During those weeks of uncertainty, many people (myself included) rushed to experiment with the capabilities of the model while it was still accessible. Sway The People!, developed through July and August, was one of my main "Fable projects": I used the model for everything in it, precisely to explore what this new class of intelligence could do, expecting all the while that it would become unavailable to me at any moment. Which, fortunately, ended up not happening!

Generative AI embedded in games

The final piece of context has to do with my own interest. I have been following the generative AI boom since early 2023, and I have always had a huge interest in games - as a matter of fact, most personal projects I had before starting to explore AI Engineering were small games. So, it is very natural to merge both trends (I did a little bit of this with LicLacMoe, though that was a very tongue-in-cheek type of project). Now that I have a good understanding of, and experience with, AI Engineering, I feel ready to start experimenting more seriously with games that have generative AI embedded into them. I am very interested in how these models (both for language and image) can expand the set of experiences that games can offer. Especially, it seems to me that they allow for extremely customized experiences, to a level that could not even be dreamt before. Sway The People! was the first experiment on this line, and I already have several other ideas in mind that I expect to explore in the following months.

Highlights

Foundational guiding documents

As I mentioned before, for Sway The People! I decided to go the full vibecoding route, delegating all coding related concerns to the AI agents. In order for this to work without becoming a hellish mess, I chose to set the stage by using the AI agent to generate a few guiding documents beforehand. These documents steer all future work (and are updated whenever needed), ensuring a minimal level of consistency in the project. I used a PRD (Product Requirements Document), a Technical Requirements document and an MVP scope document.

My flow was as follows: I started with a dump of all my ideas for the project into a notes file. This initial file was really a brainstorm: very loosely structured, written with no care for grammar or syntax, and all over the place. I then started a session with an AI coding agent (Fable, through Claude Code), which I used throughout until the guiding documents were finished. I first asked it to read the notes and ask any questions it had to clarify any points, before writing the PRD - this document would only contain product definitions, without any technical decisions or assumption. It took a few back and forth messages until it was ready, and then we moved on to the Technical Requirements document - here would be where all the important technical decisions live, including things like which programming language, which frameworks, and so on. It also took a few messages to be ready. Finally, I asked it to work with me to define the MVP scope for the initial version.

Overall I think this flow worked out fine, and gave better results that what I usually get by jumping straight into asking for a project with some specific features. The documents I described were not the only ones, but they were the new ones I used for this specific mode: I also worked with the agent to create an AGENTS.md, a README.md and an ARCHITECTURE.md files to document all the relevant info and contribution guidelines (both for AI and human agents).

Fable 5 performance

I used Anthropic's model Fable 5 for everything in the development of Sway The People!. Part of the project was experimenting and understanding the capabilities of this model, as it was said to bring a new class of intelligence in comparison with the other frontier-level models (mostly Anthropic's Opus and OpenAI's GTP 5). I found the claims to be mostly accurate: working with Fable really feels substantially different than working with any other model. The thing that most impressed me was its ability to make autonomous decisions that were, by and large, spot on. While working with other models, whenever they would reach a point where something was not very precisely specified and had to make a decision by themselves, I would more often than not have to trace back and course correct it. With Fable, however, I almost always could just let it pick a path forward and run with it, only a few times having to ask it to change something.

Pacing dictated by LLM inference speed

A peculiar aspect of the resulting game is its pacing, especially when using local models. Although I already expected any game that relies on running LLMs locally to have a slow progression, actually playing the result made it very clear that these types of games have to be designed with plenty of waiting time in mind.

The timing will definitely vary a lot based on the hardware of the player and the chosen model. I have a fairly good computer (at least by 2024's standards, when I bought it) with 16GB of VRAM plus 64GB of RAM, and mostly played with models in the 20B-30B range. For me, each creation would take a couple of minutes, making each day take anything between 10 and 30 minutes to play (depending on if it had events, influencer content creation, debates, etc.). Running the game with an 8B model made the pace dramatically faster. Different hardware, as well, should change this by a large factor. This variability seems to me one of the most complex considerations for any game aiming to use local LLMs as the main driver.

Regardless of the variability, the fact that generations always take some time (even the hosted ones) means several structural support things need to be built around them in the game. One such things I had to use in Sway The People! is a generation queue, which makes sure that generations happen asynchronously, sequentially and their results are smoothly integrated back into the game once they are complete. I consider the asynchronous aspect to be mandatory for any game using current generative AI tech in its core, otherwise the game will hang for a prohibitively long time and the user experience will be horrible. Making the generations sequential is also mandatory for most local setups (current customer hardware struggles to supply inference on even a single request at a time, let alone multiple), though it can be optional when using hosted options. And making sure that the results are smoothly integrated into the game is the most tricky one of them all, but it is absolutely essential to keep the user experience fluid. I might consolidate my thoughts about these new architectural concerns intrinsic to generative AI native games on a future blog post, and I will surely keep updating my understanding of them as I develop more projects like this one.

For me, the pacing worked very well. I am used to having several different things going on at the same time and alternating my attention between them, so I played the campaigns as a "background game", making some decisions and then turning to something else for several minutes before coming back to play the "next turn". But I admit I am probably part of a very small slice of the population that would find games with this pacing fun!

Sandbox and customization

The central idea behind using LLMs for the gameplay was to make each campaign extremely custom, in the sense that it would react to the player's choices and words in a way that is not possible with traditional coding. I am fairly confident to say that the final result proved the point.

I ran some really wild campaigns, choosing policies that ranged from fairly conventional to completely unsuited for a nation-wide program. Each time, the game reacted appropriately, even accurately raising the difficulty to an impossible level when the agenda would make no sense for a political campaign. So much so, that I had to put some arbitrary balancing constraints on the initial public opinion, so that even crazy ideas would have a minimal chance of winning the campaign based on the player's performance.

I think the influencers mechanic was particularly nice in this aspect: being able to read how each character would mold the party's agenda in a way to communicate with their particular audience really drove home how unique the new capabilities that LLMs bring for interactive entertainment are.

AI Usage statement

Outside of the software engineering and startup-pilled bubble, the current sentiment with regards to Artificial Intelligence in society is extremely negative. Especially in games, the public opinion is overwhelmingly that AI is a cheap way for companies to extract more profit while providing a lower quality product.

Due to this, I chose to write an AI usage statement for the project. In this statement, I describe why and how I believe AI can be used to provide new and unique experiences in games, and the way I used it while developing Sway The People!. I argue that not only AI makes unproven game genres more viable, but also that it can make each player's experience more unique and customized (as I talk about a few sections above in this post). I understand that the way in which large companies use AI, as a cheap way to quickly produce mediocre assets and cut off personnel costs, leads to a drop in quality and a worse ecosystem state overall, but I also believe that there are other ways in which AI can be used, which are much more beneficial for everyone. By building positive examples of such usages, hopefully we can build a better alternative and steer this technology into a better path.

I expect to include something similar in future projects, at least for the near future.

Other game genres

After having built Sway The People! as a proof of concept for using LLMs as a core mechanic for a game, I look forward to explore the same idea with other genres. While I like the idea of political sims, and enjoyed playing this game in particular, it is not really a genre I play very often. I chose it mostly because of the obvious appeal to use free text during debates and policy definitions (and also the fact that we are on an election year here in Brazil, so it is being talked about all the time).

I already have several ideas for other games using the same approach, or expanding it. All of them in different genres. I expect to be able to finish at least one more project within the year, and maybe a couple for next year. I will, of course, write about them in this blog once I release their first versions.

Future Expansions

I do not plan to expand Sway The People! much further, as I would like to move on to new projects that apply generative AI on other game genres. However, there are a couple of things I still want to implement, and some other ideas that I will leave queued up in case I decide to come back to it in the future.

Nations

The main improvement I want to make is on nations. In the MVP of the game, for every campaign a totally new nation was created by the AI model based on the chosen agendas. There were two problems with this: first, that campaigns were not replayable, if the player wanted to try to run another campaign on the same setting they would need to save at the very start of the campaign and later load that save to replay the entire campaign; and second, that nation creation is probably the most time-consuming part of the entire game, so before even starting to play the player was stuck for about half an hour waiting for the setting to be created.

For the initial release (version 1.0.0), I implemented default nations. Now the player can choose one of 3 pre-defined nations when starting a campaign, so that both of the problems mentioned before disappear. The player can also still choose to have the AI generate the entire nation if they desire, but that is a choice rather than the only possibility.

I want to implement three features related to nations (two of each I am almost certain to do before moving on from the project, the third one I am not sure yet if I will do or keep for a later time): saving the current nation during a campaign, so that the player can replay a setting they really liked; loading custom nations, so that the player can use a saved nation to start a new campaign on (which also has the nice side-effect of allowing for sharing custom nations between players); and finally, an in-game nation editor, so that the player can manually set all parameters of the nation. Saving and loading should be relatively simple features, so I intend to do them in the near future. The in-game editor is a more complex one, so I am still debating whether to implement it or keep it on hold (as long as the load nation feature is available, players can just edit the nation files to handcraft anything they like, anyway).

Campaign lengths

Currently, the game has a fixed length of 14 days for all campaigns. While I discussed briefly with Fable 5 about which length to use for the MVP, this was mostly a dummy value so that I could focus on the rest of the development. I think overall it works pretty well, though I did no research to figure out how common this length in real countries, nor did any comprehensive playtesting to determine if it is the optimal choice.

My idea is to make the length of the campaign a choice when starting a new one, just like games such as the Civilization series usually let you choose to play a short, medium, large or marathon-style session. I will probably settle for something like 14 days for a short campaign, 30 as the medium length and 90 for an epic campaign.

The main concern here is checking whether any balancing needs to be adjusted in all the public opinion calculations in order to make all campaign lengths fun. I think events and debates should not have much problem, as they can both improve and degrade the player's candidate popularity, and opponents also have their own fluctuations; but the influencer system might need to be adjusted, as their impact is always a straight bonus which might become overwhelmingly decisive on longer campaigns.

Media assets

Finally, in order to make the game an actually enjoyable experience for more people instead of a proof of concept, I would need to include media assets: music, images, animations, etc. The simplest route would be to either license or build assets and include them in new releases of the game. I might do this for a few ones: for instance, even during development I inteded to make the background image for the debate screen an actual debate stage (I even had the image to use), but I just never got to it and did not feel it was missing when playing. For simple things like that, I might still include assets.

My long term vision, however, is to also explore how image generation can be embedded into games (as I briefly explored in Chargen), much like Sway The People! already does with text generation. Once I start exploring this, I might circle back to this game and implement it here, for instance by procedurally generating image avatars for councilors, candidates, influencers, etc., or maps for nations with their regions clearly visible. I think it could add a lot of fun to the game. But I don't feel that the current state of the technology and customer hardware available is sufficient to make this feasible yet. My previous experiences trying to have an application that depends on having both an LLM and an image generation model running at the same time in the local machine does not give me much confidence that even people with generally good computers would be able to run it efficiently, and I do not know of any image generation hosted service that allows for a generous amount of free generations each day, like OpenRouter does for text generation. So this is mostly something for maybe 3 to 5 years in the future.

Setup

I developed Sway The People! intending it to be a portfolio project. For such projects, I have a set of minimal criteria I always use. Here is how it complies with those criteria, and in which ways it differs:

I use Github Actions to generate new releases for Sway The People!. Here I made a small update from my previous approach: in all previous portfolio projects, I always configured the workflow to generate the release when code was pushed to the main branch, this reflected my experience in the industry for a long time and worked fine for me through many years. However, it was somewhat clunky in the sense that I always had to keep the main branch stable and do all the development in a separate dev branch, which is overkill for a single developer project, and involved a lot of ritual around the main branch, while also having to rely on arcane commit message conventions to manage versioning increments. For Sway The People!, I changed it so that the release workflow happens triggered by a push to a version tag. This simplifies the process significantly: the version is always obvious from the tag itself, and the main branch is freed from any ritual, better reflecting the state of development.

I have a changelog file and a file with guidelines about contributing, beyond the usual readme file as documentation. This is in addition to all the vibecoding-related documents (PRD, Technical Requirements, etc.) I mentioned before.

I also included automated tests for everything except the UI code. In previous portfolio projects, I always made sure to keep a high test coverage, and favored using TDD (Test-Driven Development) while developing the projects. Since in Sway The People! my approach was to delegate all coding to the AI agent, instead of using TDD I worked together with the agent to include instructions on AGENTS.md, ARCHITECTURE.md, and all other relevant documents, guiding any contributor (AI or human) to extensively use tests for any new development. I think this worked pretty well. Despite not having directly checked the total coverage, I found very few bugs while playtesting (much less than I would have expected from a project of this scope), and while watching the logs as the agent worked I saw that several times it caught errors and bugs on its implementation by running automated tests, fixing them before completing the task. I do not know yet if this is a characteristic of Fable 5, or if other models of different intelligence classes would also achieve the same.

Links

Source code: Github

Executable: Releases

Monthly Recap - 2026-07 July

After a long while, in July I was able to once again have a very productive month with my personal projects. This years has been incredibly challenging with all the recent changes in the software industry and the uncertainties that come with them, so most of my efforts had to be shifted to compensate for that in my day job. This month, though, I was able to dedicate more time to my own things, here is a short summary of what I accomplished.

Achievements

Several new blog posts

One of the areas I had not been able to touch for several months had been this blog. While I have been trying to always write at least a monthly recap post, describing everything I have been working on during the month, the last time I had written one had been about January. This month I covered the gap, and wrote the recap of what I did every month, up until June. Thankfully I keep quite well-organized notes about everything I work on, so it was not that hard to figure out what went in which month.

Beyond this, I also wrote two more blog posts, one describing my experience with opencode and the other with my analysis of volume 34 of Thoughtworks' Technology Radar. I had been meaning to do both for a long time. The first one I wanted to write because it goes off the beaten path of Claude Code, Codex, etc. I really think opencode brings a promise of cheap experimentation that is very much worth talking about. The second one is an exercise I have been meaning to do ever since I started this blog, which is to share my thoughts about the main discussions happening in the software engineering world. I had already written some posts summarizing my experience in conferences, but never went deep into any major report. The Technology Radar is one that I read every single edition for the past 5 or 6 years, so it was a very natural first choice. And I intend to continue doing so with future editions.

Finished studying Fundamentals Of Software Engineering

I picked up Fundamentals Of Software Engineering as part of my personal studies habit midway through last year, as I was switching teams to work on a new product. I thought it would be a great opportunity to get a stronger theoretical grounding on software architecture, as I would be once again witnessing one emerge. While it was a very bumpy road from then until now, I think studying this book was mostly a positive experience, and while I did not learn a whole lot from it, it helped me organize my thoughts and categorize several ideas and concepts.

First pre-release of new portfolio project

July also saw the first pre-release of my new portfolio project. My last such project was LicLacMoe, which I released in early 2025 (more than a year ago). My plan since 2023 has been to release at a minimum one new portfolio project a year, and ideally two per year. With this new project coming up, I remain on track with the plan for the third year in a row. Although the project can already be found in my GitHub profile, I do not want to talk too much about it yet, as I still intend to improve it before making the first official / major version release. Once I do, I will write a dedicated blog post for it, and include a mention in the respective monthly recap post.

Plans for next month

Start next career book studies

Since I finished Fundamentals Of Software Engineering on July, I am now ready to pick up the next book to study on the career track of my personal studies habit. I am evaluating the ones I had in my backlog in order to pick up the one that makes the most sense right now. By August I should have finished choosing and started studying the next one.

First full release of new portfolio project

As I mentioned before, I have a brand new portfolio project coming up. While the version 0.0.1 is already available, I should soon have the first major version, 1.0.0 ready to release. In August I expect to make this release and write up a blog post about the project, as I have done previously for each recent portfolio project.

Thoughtworks - Technology Radar 34

Intro

Twice a year, Thoughtworks publishes its Technology Radar, an opinionated guide to the current technology landscape. It organizes notable technologies and practices (which they call blips) into four quadrants: Techniques, Tools, Platforms, and Languages & Frameworks; and four rings that express how confident they are in recommending each one, from "Adopt" down to what used to be called "Hold". I have been following the Radar for several years now, and reading each new edition has become something of a ritual for me. Volume 34 came out in April of 2026, but this time I was only able to read it in July, so parts of it already felt slightly outdated... which says as much about the current pace of the industry as it does about my reading backlog. Here are my thoughts on this edition.

General Comments

The first thing that caught my attention was a change to the Radar itself: the "Hold" ring has been renamed to "Caution". I dislike this change. It feels like an unnecessary cave in to the current hype machine, which insists that everything new must be flawless and that pointing out problems is bad for business. Being able to take a stand and argue against certain things, when one has strong arguments, is important for any serious conversation about technology, and softening the language of the ring that exists precisely for that purpose seems like a step in the wrong direction.

The distribution of blips across the rings tells an interesting story. There are 62 blips on Assess and 30 on Trial, against only 17 on Adopt and 9 on Caution. That overwhelming concentration in the middle rings feels very symptomatic of the times we are living in: there is an explosion of new things appearing, and it is necessary to at least keep track of most of them, while investing time to go deep into only a few. It is also striking how few blips landed on Caution - eight of the nine are Techniques, one is a Tool, and there are none at all in Platforms or Languages & Frameworks. The Platforms quadrant, in fact, has zero blips in both Adopt and Caution: everything in it sits in the middle, still being evaluated, with nothing yet considered either safe enough to fully recommend or problematic enough to warn against.

All four themes of this edition are related to AI: "The challenge of evaluating technology in an agentic world", "Retaining principles, relinquishing patterns", "Securing permission-hungry agents" and "Putting coding agents on a leash". It is the second time that this is the case, in previous editions there used to always be at least one theme dedicated to something else, as an effort to keep a broader view of the ecosystem. The four themes seem to form two couples: the first two are about how we humans are changing to adapt to this new model of working, while the last two are about the technical side of embedding generative AI models within a useful "exoskeleton" that is both effective and safe.

Highlights

OpenClaw is the only tool placed under Caution, and to me it is a clear portrait of the current state of AI hype. It made a huge impact when it was first released, and just a few weeks later it was already far less talked about... by now, it is rarely mentioned at all. I was always skeptical about the "hyper-personal AI assistant" category itself, as I see little value in delegating relevant choices of my life to an artificial intelligence. But beyond my personal preferences, the trajectory of OpenClaw illustrates the broader pattern: there is a huge push towards adopting every new thing that appears, without any clear success story that has proved itself over sufficient circumstances.

The agentic coding tools, on the other hand, are where the consolidation is most visible. Cursor reached Adopt, and it was one of the first agentic IDEs I tried, early on. I had an overall good experience with it, though not a very remarkable one. It holds the distinction of being the only agentic coding tool with which I hit a token budget limit while coding (the only other time that happened was with Claude Code, and that was because I was testing Fable, a model with a more restrictive budget). Since the limit appeared unexpectedly, midway through development, I switched to Windsurf and never went back: overall, I preferred working with Windsurf. On Assess, Pi is one I find very promising: I have seen some very interesting proof of concept projects using the Pi SDK as a framework on top of which entire TypeScript systems are built, UI and backend included. It seems like a great candidate to bridge the gap between AI agents and traditional applications, enabling truly agentic applications, and I am very interested in testing it soon. Also on Assess is OpenCode, which became a true milestone in my routine - it is now my tool of choice for simpler or more exploratory tasks, and I wrote a dedicated post about it recently. And finally, Claude Code reached Adopt, having indeed become the industry standard for agentic AI coding: I have been using it extensively, reserving it for the complex tasks that demand state-of-the-art intelligence.

Small language models appearing on Assess caught my attention for a different reason. By "small", the Radar means models of 3B parameters and below, which sits just outside the range I most commonly explore in my personal open source projects - JenAI, LLP and Chargen are built to work with models in the 8B to 70B range. Adding the frontier models I use for development, there is now a whole spectrum of model sizes, each serving its own purpose. I like to think this shows we are starting to reach some level of maturity in employing AI for actual use cases, moving beyond mere experimentation: choosing the right size of model for the job is the kind of engineering decision that only becomes relevant once the technology is being put to real work.

Curated shared instructions for software teams reaching Adopt was particularly satisfying to see. As an InnerSource champion, I have been talking within my company about how AGENTS.md and similar instruction guidelines for agents are now an important and integral part of any project, and how they enable more effective collaboration even from outside contributors. I have given a series of talks about this in internal events already, and I plan to at least write a blog post on the topic soon.

Codebase cognitive debt, placed under Caution, names one of my main concerns with the current shift to AI-assisted software engineering. I have developed software across the whole spectrum that goes from full vibe-coding (just ask the AI and go with whatever it produces, without even looking at the code) to purely human-written code, and I have had successful results at every point of it. But the characteristics of those successes are different, and being distant from the code still does not feel as reliable and sustainable as being hands-on. A big part of being proficient at developing a software system lies in the mental map one has of it, and not being actively engaged in writing the code erodes that map very quickly. This fundamentally changes the process of software engineering. When humans write all of the code, the more you work on a system, the better you become at working on it, because your mental map keeps expanding. When humans stop looking at the code, the relationship inverts: the more you work on the system, the less proficient you become, as the code evolves in ways you can no longer clearly picture. There is no turning back, and the current push in the industry is for humans to be as far out of the loop as possible in order to gain development speed. But we have not lived with this model long enough to have clear success stories that have stood the test of time and proved it sustainable... and until we have those stories, I remain cautiously skeptical.

Things Tested And To Test

Beyond the highlights, several other blips crossed paths with my own explorations. Among the things I have already tested are LangGraph (which I have used as my default choice of AI agents framework - the Radar moved it out of Adopt and into Trial, as there are newer alternatives that can compete with it now), Google's Agent Development Kit (ADK) (which I used briefly when assessing different agent frameworks, and enjoyed more than other alternatives I also tried such as CrewAI, as it maps better to a software engineering mindset - the Radar's main criticism is that it is still pre-GA) and HTML Tools (the first time I see this explicitly named, but an approach I have been following for a while: whenever I ask a coding agent for a report, I ask for the findings consolidated in a nicely stylized standalone HTML page, which reads much better than the default markdown).

On the list of things I want to test are Mastra (a TypeScript-native open source framework for building AI applications and agents), team of coding agents (a technique I have only limited experience with so far), code intelligence as agentic tooling (I have not yet explored much of the Language Server Protocol as a way for LLMs to work more efficiently, but it is high on my list) and mutation testing (an idea I have known for years and was always skeptical about for human-written code, but as a "test-the-test" approach for AI-generated test suites, which realistically no one will fully review, it finally starts making sense to me).

Closing Thoughts

Stepping back, the picture this edition paints matches what I see in my daily work. Kent Beck describes the life of a product in three phases, his "3X" model: Explore, when you cheaply try many things in search of what works; Expand, when something has caught on and you scale it while removing bottlenecks; and Extract, when the ground is stable enough to optimize for efficiency. The AI-dominated landscape of this Radar feels like an industry moving from Explore into Expand: the explosion of new things being created continues (hence the crowded Assess and Trial rings), consolidation is beginning around a few winners (hence Claude Code and Cursor on Adopt), but there is still no concrete success story that has stood the test of time... which is precisely why so much of the Radar remains in the middle rings, and why I keep some healthy skepticism about the most aggressive promises being made.

The next edition of the Technology Radar should be released around October or November of this year. I intend to once again read it (hopefully closer to the release date this time) and share my thoughts here on the blog.

Exploring opencode

I started using opencode around May of 2026, and it truly felt like a milestone in incorporating AI into my daily routine. I mentioned in my May monthly recap that I intended to write a dedicated post about the experience, this is that post.

Some context first. I started using AI coding agents (or harnesses, as I prefer to call them) around August of 2025, with Cline on VSCode, and then moved on to Claude Code in January of 2026. In both cases this happened at work, for purely professional purposes, coding and other software engineering tasks. It was only when I began experimenting with these tools on my personal computer, for a much broader range of tasks, that I eventually discovered opencode. It was a spark that changed a lot of how I think about and use harnesses, for a few reasons.

What Sets It Apart

Install And Start Using

The first thing that struck me is how simple the setup is. With every other harness I have used or looked into (Cline, Claude Code, Codex, etc.), there is a whole ritual before you can do anything: create an account, choose a subscription plan, log in through the tool, and so on. With opencode, you install it and start using it. That is the entire onboarding. It sounds like a small thing, but it completely changes the feeling of picking up the tool for the first time.

Free Access To Reasonably Good Models

The second reason is that opencode currently offers free access to reasonably good models, without any severe limits. The obvious caveat: it is impossible to know for how long this will be sustainable, and opencode might well start limiting usage or requiring a paid subscription in the future. The slightly less obvious caveat: every session needs to be treated as likely shared with the companies that created the model, as the simplest benefit a company can get from giving access to their models for free is data for future training... so, best not to share any personal or sensitive information. Regardless, right now it makes opencode a perfect tool for experimentation.

By lowering the cost of exploration to basically zero, it allows everyone to try the harness for all sorts of things, not just coding. These tools have access to terminal commands, beyond reading files and accessing the web - which means that anything that can be done on a computer can be explored through AI with them. And a huge amount of our society runs on computers, so the potential is enormous. To give a few examples of things I have done: searching for a public, free web radio station from any country (Argentine rock forever!) and playing it directly through the terminal, looking up lyrics and other info about new music I found, and debugging and fixing a broken game installation by letting the agent look at the actual configuration files. Without the burden of knowing you have a certain limit of tokens to spend, you feel free to explore all sorts of random things that an AI agent might do with a computer.

I am even considering making opencode the very first thing I install, the next time I setup a brand new OS installation (likely Linux, as it is my default OS). I find it intriguing to think what an AI-based distro would look like, though I would not want to go to the extreme yet. In my mind just being able to bootstrap the OS with opencode, and then using it to install everything else that I need (as it would have access to the package manager of the distro) by just talking with the computer feels really cool.

Open And Provider-Agnostic

The third reason is that opencode is a fully detached, open source agentic harness that can work with models from several providers. Most tools in this category fail at least one of these criteria: they are IDE-first (Cline), closed source, or tied to the provider that created them (Claude Code with Anthropic, Codex with OpenAI). Pi is an alternative that is also detached, open source and provider-agnostic, but it is far less complete when it comes to features and capabilities.

Being provider-agnostic also means opencode can be used with local models. So even if the free access to hosted models disappears in the future, it will still be possible to run it for free with local ones. That is a kind of insurance that no closed, single-provider tool can offer.

Limitations

Despite all the positive aspects, there are some limitations as well:

Model Quality

While the free hosted models are good, they do not reach the same level of quality as frontier models. For more complex or nuanced tasks, they often do not achieve the best results. This can be worked around with more guidance and handholding from the user, but it takes more work. For the absolute best quality, proprietary models (which usually work better with their own company's harness) are still the way to go.

Context Management

Context management is often a problem. Most of the free models offered have a context size of at most 128k tokens, which gets consumed very quickly - the tool seems to be quite aggressive about how much it puts into the context. It does perform automatic summarization when it gets close to filling the available context, which is good, but more often than not the summarization loses some information that is essential to the task at hand. In practice, this means the quality of the results degrades very quickly, making opencode not very suitable for long-running tasks.

Closing Thoughts

For me, the real significance of opencode is not any single feature, but what the combination enables: a tool that anyone can install and immediately start using to explore what AI agents can do with a computer, at no cost. The frontier of quality still belongs to the proprietary models and their harnesses, and the limitations around context are real. But as a gateway for experimentation, and as an open, provider-agnostic foundation that will keep working regardless of what any single company decides, it has earned a permanent place in my toolbox. I expect to keep exploring what these agents can do well beyond coding, and I am sure some of those experiments will end up here on the blog.

Monthly Recap - 2026-06 June

After two very intense months of working overtime in April and May, June finally saw things gradually getting back to a more sustainable pace. I chose to take it easy and not use all of the newly available free time for personal work though, as I felt like I was very close to getting burnt out if I maintained the same rhythm. I hope that taking a few weeks now, mid way through the year, to rest and re-energize will allow me to have a very productive and purposeful second half of 2026. Here's a quick summary of what went on in June for me.

Achievements

Personal Studies Progress

My personal studies habit got quite messy over the last year, and I have not done a great job of describing what I have been doing in the last few monthly recaps, so I will take a short moment to put everything back on track here. At about the middle of last year (2025), it became clear that the software development ecosystem was finally locking in to embed AI in its core loop. While I had been exploring the field for about a couple of years already by then, I felt the need to build a more comprehensive and grounded understanding of the possibilities and implications of this shift - so, I picked up two books on the topic to study (AI Engineering and Beyond Vibe Coding).

At the time, I was already studying two other books. This, coupled with a transition to a new team (and organization) within my company, with a whole new tech stack, proved to be too much change in too compressed a timeframe, and so I went through a couple of not very productive months just struggling with too many things to do and progressing too little on each of them. Early this year, I organized myself to address this, and reduced the amount of books I was working through at a time. So, as I mentioned in previous recaps, I finished them one by one, the last one being AI Engineering.

In June I finally reached the stage in which I could move on to pick new books to study. The first one has been Nexus, by Yuval Harari - I have been a huge fan of his work for more than a decade now, having deeply enjoyed Sapiens and Homo Deus, so naturally I wanted to go through the rest of his work. So far, it has been totally worth it, and I will share more of my thoughts once I finish it.

Electron

While I have developed several tools and apps to be used on desktop environments in the past, they have always been restricted to one of three stacks: simple Python apps with TKinter (one of the first programming languages I learned, always feels very comfortable to go back to), Java apps leveraging Swing for the UI (Java being my main professional programming language for cloud and microservices systems, it was always tempting to accept an old and rusty visual presentation in order to do what I consider myself to be best at) or straight out web apps based on HTML and JavaScript running on localhost (made for better visual presentation while still allowing me to leverage over a decade of experience writing cloud systems, but was a very clunky distribution model).

After learning about the open source Pi coding agent, and seeing some creative usage of it embedded in applications through its TypeScript SDK, I got really interested in exploring its ability to embed AI agents within applications. So I used this as an opportunity to finally do something I've been meaning to for several years now: learn Electron. This will allow me to create desktop apps with agentic capabilities, something that gets me really excited. And also, by using Electron I believe I will be able to continue leveraging my knowledge of web frontend technologies while having a much better distribution model for desktop apps.

I went through Stephen Grider's Udemy Electron course to do this, and it was a really great short introduction. Throughout the years, I have taken several of his courses, and his style always resonated a lot with me. The combination of going very deep into the fundamentals of what is going on and getting that understanding, plus having a preference for code-along sessions instead of just showing the final result is an incredibly effective teaching style. Based on my previous experiences I expected this course to do the trick, and it definitely did.

Plans for next month

For July, the main things I expect to achieve are starting the next career-related book in my personal studies (the ideal number for me is 2, one for career and one for hobbies - currently I am working only on Nexus) and continue building personal applications that explore agentic capabilities woven into specific workflows. I am definitely focusing on Electron + Pi at the moment, but I will also try to build a few experiments with LangChain, as that seems to be the standard that the market is converging on for now.

Monthly Recap - 2026-05 May

May continued the intense overtime push of April, but having been operating in this manner for a while, I was able to get more things done even with little free time. Here is a quick summary.

Achievements

Finished AI Engineering book

After restarting AI Engineering, by Chip Huyen, in April, I was able to finish it this month. This is one of the most highly regarded books in this new field, and for good reason. It covers the full lifecycle of AI systems - from data engineering and model selection to deployment, monitoring, and responsible AI practices in production. While I already had some practical experience with several of these topics from building JenAI and other personal projects, the book helped me contextualize and structure that knowledge in a way I had not been able to before. I am glad I was able to finally complete it, and although it goes in depth on some areas that I normally do not touch (such as model training and fine tuning), I feel like this will be a reference I come back to often.

Started using opencode

This month I also started using opencode, an open-source AI-powered coding assistant. I intend to write a dedicated post about this, as I found the experience really intriguing. For now, it suffices to say that agentic coding assistants in general really feel like the next step for AI. Not the end state, but a significant (and positive) advancement in the capabilities that this technology bring to the table. I already used Claude Code to a good extent, but having an open source alternative, which has flexibility to work with several models from different providers, and comes out of the box with free options, democratizes the access to a whole new level. Really excited to explore the implications of this!

Started AI Engineering Track Udemy course

To complement the book studies, I also started the AI Engineering Track on Udemy. This is a more hands-on, practical course with a stronger emphasis on implementation and tooling. I have just started working through it, and my plan is to go through it systematically over the next few months.

Monthly Recap - 2026-04 April

April was a month with very little spare time for me. A huge rush to wrap up the work for the mid-year event of my company meant that every developer worked double shifts during this period. The bright part is that this time I was able to keep up my personal studies habit - although not much else. Here's a quick summary.

Achievements

Restarted AI Engineering

Last year I started studying AI Engineering, by Chip Huyen. This is one of the most highly regarded book in this new field, with some of the most prominent people in software engineering giving it high praise. Due to the several competing priorities along the way, though, I had to stop studying it for several months. Having just finished Beyond Vibe Coding in March, this month I was finally able to restart it. Maintaining consistency with this habit has been a focus for me this year, and I am very glad I was able to stick with it this month, despite the challenges.

Downpoints

Overtime

As I mentioned before, April was a very difficult month with regards to work-life balance. Of course, having to put some extra effort at specific times when the company needs is part of being a professional, but I hope this does not become the new normal for us.