<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by techwithmatheus on Medium]]></title>
        <description><![CDATA[Stories by techwithmatheus on Medium]]></description>
        <link>https://medium.com/@techwithmatheus?source=rss-c154d483a24b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dr8gpK7VWY2Uz8Jf_N7CTA.jpeg</url>
            <title>Stories by techwithmatheus on Medium</title>
            <link>https://medium.com/@techwithmatheus?source=rss-c154d483a24b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 01:17:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@techwithmatheus/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI Game Mashups: Can AI Really Turn Two Games Into One?]]></title>
            <link>https://medium.com/@techwithmatheus/ai-game-mashups-can-ai-really-turn-two-games-into-one-3c3262f4b072?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3c3262f4b072</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 11:53:38 GMT</pubDate>
            <atom:updated>2026-10-29T11:53:38.943Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3cMxJ4w730JE-a73hyVajw.png" /></figure><p>Mario shooting some baddies in Halo. Minecraft inside GTA V (<a href="https://dev.to/aws/ai-game-mashups-can-ai-really-turn-two-games-into-one-52bd#appendix-a-real-world-example">see Appendix: a real-world example</a>). A social media trend has people sharing videos of what’s being branded as “AI game mashups.” The claim is that people have used AI to reverse engineer different games and mash them together into one in unexpected or cool ways… but is that the whole story?</p><p>As usual, hype has a tendency to exaggerate things to create, well, more hype. So let’s separate reality from fiction and explore what’s actually happening behind these demos.</p><p>The good news is that there is plenty on the reality side to be mind-blown about! However, there are also some disappointing truths. At least for the time being.</p><h3>Let’s Mash Candy Crush And Call of Duty!</h3><p>Let’s walk through a ridiculous combination as a practical example. Let’s imagine that we want to combine Candy Crush and Call of Duty!</p><p>However, simply naming two games does not constitute a plan. Like anything else, first we need to work out our requirements and architectural concerns.</p><p>Here’s my take: every time you reload your weapon, Candy Crush loads inside the Call of Duty gameplay and you have to complete a match-three puzzle before the reload can finish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*3nzfsDgt7jfIeaAU.png" /></figure><p><em>Hypothetical mashup: solve a match-three puzzle to finish reloading. AI-generated concept illustration, not a screenshot of a working mod.</em></p><p>I have no idea whether that would be fun. I suspect my teammates would have opinions. But at least we now have something concrete enough to discuss.</p><p>There are still decisions to make though. Does the shooter pause while you solve the puzzle? What happens if you fail? Can you cancel? Does a harder puzzle earn you more ammunition?</p><p>Neither original game contains the answers so it’s up to us to introduce new rules.</p><p>And that is our first lesson: <strong>Connecting two game engines does not automatically create coherent new gameplay.</strong> Somebody, potentially with AI assistance, still has to decide what the connection means and implement it.</p><h3>What Are We Actually Mashing Together?</h3><p>When I watch these demos, I find it useful to separate four things.</p><p>What’s happeningWhat it establishesVisual compositionImages or rendered objects from different sources appear together.Event integrationSomething happening in one game triggers something in another.Gameplay orchestrationNew rules coordinate actions and state across the games.Hybrid game designThose rules form a coherent experience with its own objectives, constraints and balance.</p><p>These can overlap. A project might combine graphics and translate a few events without sharing every part of either simulation.</p><p>For example, an explosion in one game could trigger an explosion in another. That is a meaningful integration, but it doesn’t, by itself, establish that every object in both worlds can collide, that both physics engines agree, or that every mission works across the boundary.</p><p>A clip can still demonstrate a specific interaction beautifully while leaving those broader questions unanswered.</p><h3>The missing interfaces</h3><p>Ok, so how can we go about implementing our Call of Duty and Candy Crush mash-up? Well, to begin with we need to discover each game’s available integration points. Then we need to find a way to connect those before finally figuring out how to coordinate the result.</p><h3>1. Find a way to control the relevant behaviour</h3><p>A game with a supported modding API might already expose the events and controls we need. Otherwise, investigating its internal behaviour may be necessary.</p><p>For our shooter, we would need to identify a reload request and find a reliable way to defer it. For the puzzle, we need to start a challenge and detect its completion. Observing an animation on screen is different from having a dependable signal that the underlying action succeeded.</p><p>This is where reverse engineering can contribute: <em>working out how software behaves when its original source code or a suitable interface isn’t available.</em></p><p><a href="https://github.com/morluto/rea">REA, or Reverse Engineer Anything</a>, is one project in this area and the one behind the viral game mashups trend. Its documentation describes connecting agents to analysis tools, including Ghidra, Hopper and IDA, and returning findings that an agent can investigate further.</p><p>It is indeed a pretty cool tool that gives an agent ways to inspect software. However, it is NOT a magical command that enables agents to recover an entire game’s original source project or to understand every subsystem.</p><p><em>Moreover, it’s important to remember that runtime modification of games predates AI tools.</em></p><p><a href="https://github.com/soulsmods/ModEngine2">Mod Engine 2</a>, for example, documents runtime patching and injection for Souls games, including Elden Ring.[3] Existing tools and community knowledge are part of the foundation here.</p><h3>2. Build interfaces between the games</h3><p>Once we understand the relevant behaviour, we can build adapters: code that translates between what our mashup needs and what each game can actually do.</p><p>From the coordinating code’s perspective, the shooter adapter might offer operations such as “defer reload” or “resume gameplay.” The puzzle adapter might offer “start challenge” and a completion event.</p><p>Those are interfaces that we have to build unless the game itself provides out-of-the-box integration points, or in simpler language, hooks. This could be, for example, official support for mods. That means creating and maintaining your own adapter code, which, yes, you can also use AI to help you generate.</p><p>There is an added complication: If components run in separate processes, they need a way to exchange messages, such as sockets or named pipes. This is referred to as inter-process communication, often shortened to IPC.</p><p>A hook and a communication channel have different jobs. A hook can intercept behaviour inside a game whereas IPC lets separate processes exchange information. Having one doesn’t automatically give us the other.</p><p>Either way, we arrive at our second lesson: AI doesn’t somehow make two incompatible executables magically understand each other. <em>The real magic is that AI can help us build the missing interfaces between them.</em></p><h3>3. Implement the new rules</h3><p>Now we need the coordinator, or orchestrator, that implements our reload rule so we can load Candy Crush every time you need to reload your weapon on Call of Duty.</p><p>Here’s the plan: it receives a reload request, defers the action, puts the shooter into an appropriate paused state, and opens the puzzle. On success, it allows the reload to proceed and returns control to the shooter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2f6aJPP4sfrPMkuPDgYVMw.png" /><figcaption><em>The orchestrator coordinates the reload and puzzle, with a recovery path for failure, cancellation or timeout. This conceptual flow assumes the required integration points exist.</em></figcaption></figure><p><em>The orchestrator coordinates the reload and puzzle, with a recovery path for failure, cancellation or timeout. This conceptual flow assumes the required integration points exist.</em></p><p>What if the puzzle crashes though? The player shouldn’t remain trapped forever with a frozen gun. And how about if a completion message arrives twice? We need to be careful not to grant ammunition twice. Like any piece of software we need to design for our error conditions.</p><p>This is why “pause the game” deserves scrutiny. Preventing player input is different from pausing the simulation. In a networked game, the server and other players may continue regardless. Our example depends on capabilities that may be unavailable or prohibited in a protected online title.</p><p>If you work with microservices, there’s a familiar architectural idea here. Connecting two services doesn’t automatically create an e-commerce application. You still need rules that define what placing an order means, what happens next, and how failure is handled.</p><p>Games add another difficulty, one that becomes our third lesson: <em>we still need to design and build gameplay rules for the mashup much like building any other game.</em></p><h3>Do the games become one program?</h3><p>They don’t have to.</p><p>In one possible implementation of our example, the shooter and puzzle remain separate processes while our own coordinator manages their behaviour and presentation.</p><p>The simplest implementation may be, for example, switching back and forth between the Candy Crush puzzle’s window and the Call of Duty window. A more integrated version could display the puzzle within the shooter’s view as ensioned in our concept above. We’ll have to work harder for it because it then adds rendering and input-routing work but it does look super cool. Either way, the objective is to have the player experience a single set of rules while multiple programs do the work.</p><p>Another consideration is whether we need to create our own launcher app. This could gives even more control over the runtime and coordination between the two processes running either game, however it does not automatically give control over either game’s internals.</p><p>So lesson four is: <em>the desired user experience dictates how much control you need to have over either game and determines the architectural choices as well as the amount of code that you need to write and maintain.</em></p><h3>Where did the graphics come from?</h3><p>This is perhaps the most intriguing question.</p><p>A newly written game might use original artwork, generated assets, placeholders or reused material. A mod might leave the original game’s engine and assets in place. A mashup might combine output from two running engines, each rendering its own content.</p><p>Those are different workflows. A familiar character on screen doesn’t tell you which one happened.</p><p>In our hypothetical example, if both original games were running, neither would need its graphics recreated merely to appear in the experience. Each game already knows how to render its own world. The integration challenge would concern control, communication, presentation and the new rules.</p><p>Conversely, reproducing familiar graphics in a newly written program doesn’t establish that the original physics, enemy behaviour, timing or levels have been reproduced.</p><p>But hang on. If we put Mario inside Halo, how does he know where the floor is? Doesn’t he come with his own bounding box? The important distinction is that <strong>a character’s appearance and its collision behaviour are separate things</strong>. A visible model doesn’t automatically bring a working physics system with it.</p><p>For a hypothetical model replacement, we could give an existing Halo character Mario’s appearance while keeping the host character’s movement and collision setup. Or, if we were adding a new character, we would need to create or convert the collision data into a form the host engine understands and configure its behaviour. Halo wouldn’t need to recognise “Mario”; it would need a correctly configured character in its own simulation. That could stop him falling through the floor without reproducing how he moves in a Mario game.</p><p>So lesson number five is: <strong>Looking like two worlds have merged does not mean that their physics have merged too. There’s work to be done to make that happen.</strong></p><p>Asset provenance and permission are also separate questions from whether an integration works. A clip alone cannot answer them. Before making claims about how a creator obtained the assets, we need their documentation.</p><h3>Where does the AI fit?</h3><p>We should distinguish AI helping build the mashup from AI running it.</p><p>During development, an agent can use tools to investigate behaviour, propose integration code and help iterate on failures. REA’s documented workflow, for example, lets an agent inspect findings, ask follow-up questions, and write and test an implementation.[2]</p><p>But once our reload rule works, it can run as ordinary deterministic code. Receive the event, start the puzzle, wait for a result, update the state. There is no inherent need to ask a language model what should happen every time the player reloads.</p><p><em>AI can be the engineer that builds the bridge without being the driver that crosses it.</em></p><p>That distinction also helps us evaluate claims about speed. A successful demo shows that someone achieved a result. Understanding how much AI accelerated it requires more evidence: the starting tools, existing mods, development history, human interventions and failed attempts. The finished clip doesn’t contain that history.</p><h3>Appreciate the demo. Be precise about the claim.</h3><p>I find this trend exciting because it opens up questions about what people might build when investigating and connecting unfamiliar software becomes more accessible. Not to mention that level of creativity which makes me smile or even laugh out loud every time I see one out there.</p><p>But, if we’re gonna get down to the nitty and gritty and talk technical, I scrutinize them about what they’re trying to prove. What is running? How much of it is custom integration and coordination code? Which information crosses the boundary? Which interactions actually work? Where does the AI contribute?</p><p>An overlay, an event bridge and a hybrid game can all be worthwhile achievements. Describing them accurately gives the people building them credit for the work they actually did, and gives everyone else a better understanding of what remains unsolved.</p><p>Reverse engineering exposes capabilities. Integration connects them. Orchestration gives them new meaning.</p><p>Whatever the path you take, ultimately it comes down to our final lesson number six: <em>AI or no AI, REA or whatever comes next…game mashups are a project like any other and still take a lot of work!</em></p><p>As for whether solving Candy Crush puzzles before reloading a gun in Call of Duty is a good idea…that is up for debate!</p><h3>Appendix: A real-world example</h3><p>The <a href="https://github.com/rehan-remade/universal-modder">Universal Modder repository</a> documents a Minecraft and GTA V story-mode example. Its description identifies a Minecraft Fabric mod, a ScriptHookV component and a ReShade add-on, with camera, ground and event information exchanged over a local WebSocket connection. It also describes combining Minecraft’s colour and depth output with GTA’s frame, and translating selected Minecraft events into GTA effects.[1]</p><p>There are two useful ideas in that description.</p><p>First, the games have specific integration components. A communication channel carries information, but code still has to decide what to send and what the receiving game should do with it.</p><p>Second, presentation and interaction are separate problems. Depth information helps decide which rendered surfaces should appear in front of others. That can make the combined image convincing. Making an object affect the other game’s simulation requires additional behaviour.</p><p>That is a substantial achievement. It is also a much more precise claim than “any two games can now be merged.” The project’s documented approach is evidence about that example, not a universal explanation for every viral mashup.</p><h3>Sources</h3><p>Project documentation checked on 20 October 2026; collision reference added on 29 October 2026. Named implementations are described from their maintainers’ documentation; I have not independently run or benchmarked them.</p><ol><li><a href="https://github.com/rehan-remade/universal-modder#built-with-it">Universal Modder: documented Minecraft × GTA V example</a>.</li><li><a href="https://github.com/morluto/rea#how-rea-works">REA: overview and how it works</a>.</li><li><a href="https://github.com/soulsmods/ModEngine2">Mod Engine 2: runtime patching, launcher and extension documentation</a>.</li><li><a href="https://docs.godotengine.org/en/stable/tutorials/physics/physics_introduction.html">Godot documentation: collision shapes, physics bodies and collision response</a>. General collision concepts; not evidence of a particular Halo mod implementation.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3c3262f4b072" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Switching Between Your Personal ChatGPT Account and Amazon Bedrock]]></title>
            <link>https://medium.com/@techwithmatheus/switching-between-your-personal-chatgpt-account-and-amazon-bedrock-93e7ef06a8cc?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/93e7ef06a8cc</guid>
            <category><![CDATA[openai-codex]]></category>
            <category><![CDATA[amazon-bedrock]]></category>
            <category><![CDATA[chatgpt]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Fri, 02 Oct 2026 15:17:18 GMT</pubDate>
            <atom:updated>2026-10-02T15:17:18.259Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Illustration of switching between personal ChatGPT and Amazon Bedrock while using the same laptop workspace." src="https://cdn-images-1.medium.com/proxy/0*ydUvcJW66enxKNxL.png" /></figure><p>In the <a href="https://matheusguimaraes.com/writing/set-up-chatgpt-desktop-app-amazon-bedrock">previous post in this series</a>, I walked through how to configure the ChatGPT desktop app to use OpenAI models through Amazon Bedrock.</p><p>That works great if Bedrock is the only environment you want to use. But what if you want to use both your personal ChatGPT account and Amazon Bedrock?</p><p>That’s when it gets awkward.</p><p>I found that out the hard way after setting up my Bedrock configuration, because my intention was always to keep using my personal ChatGPT account as well and switch between the two on demand to help me manage my token limits.</p><p>I also didn’t want two completely separate Codex environments. I wanted to keep the same local conversations, files and working state, and simply change which provider was handling the model requests.</p><p>So I built a small account switcher to make that easier.</p><p>If you just want the solution, you can grab it here:</p><p><a href="https://github.com/techwithmatheus/codex-account-switcher"><strong>techwithmatheus/codex-account-switcher</strong></a></p><p>It includes an installer, uninstaller and two simple commands:</p><pre>codex-personal<br>codex-bedrock</pre><p>If you’d rather understand what it’s doing before installing it, keep reading. That’s what the rest of this post is about.</p><h3>The problem with simply switching accounts</h3><p>When you’re using the normal ChatGPT experience, switching accounts is something you generally think about at the application level.</p><p>Bedrock is different.</p><p>In the setup from the previous post, Codex is configured locally with something like:</p><pre>model = &quot;openai.gpt-6-astra&quot;<br>model_provider = &quot;amazon-bedrock&quot;<br>[model_providers.amazon-bedrock.aws]<br>profile = &quot;codex-bedrock&quot;<br>region = &quot;us-west-2&quot;<br>wire_api = &quot;responses&quot;</pre><p>That tells Codex to send model requests through Amazon Bedrock using the AWS profile and Region you’ve configured.</p><p>So Bedrock isn’t another ChatGPT account that can simply appear in the normal account switcher. It’s a different model-provider configuration.</p><p>My first thought was therefore to maintain two separate Codex environments: one for my personal account and another for Bedrock.</p><p>That would work, but there’s a downside.</p><h3>Why I decided not to separate the whole Codex environment</h3><p>Codex stores its local state under:</p><pre>~/.codex</pre><p>And there’s considerably more in there than config.toml.</p><p>On my machine, that directory contains authentication state, sessions, thread history, memories, plugins, skills, model caches, trusted-project settings and several local databases used by the desktop experience.</p><p>If I gave my personal and Bedrock setups completely separate Codex homes, I would also be separating much of that useful state.</p><p>That wasn’t really what I wanted.</p><p>My use case was closer to this:</p><pre>same Codex workspace<br>same conversations<br>same local state<br>different model provider</pre><p>So I tried something simpler.</p><p>I completely quit the ChatGPT app, removed only the Bedrock-specific configuration from ~/.codex/config.toml, and launched it again.</p><p>The desktop app returned to my personal ChatGPT-backed Codex environment.</p><p>More importantly, a test conversation that I had originally created while using Bedrock was still there. It contained a small .NET console application, and I could still open the generated files in the desktop preview.</p><p>I then quit the app, restored the Bedrock configuration and launched it again.</p><p>The same conversation and files were still there.</p><p>So that’s the model we’ll use here: <strong>keep the Codex state shared and switch only the part of the configuration that selects Amazon Bedrock.</strong></p><p>There was another nice surprise when I later tested the full uninstall flow. When I switched back to my personal ChatGPT environment, I expected to have to sign in again. I didn’t.</p><p>My existing personal authentication was still part of the shared Codex state. Bedrock had changed which provider handled the model requests, but it hadn’t logged me out of my personal ChatGPT account.</p><blockquote><em>This is behaviour I’ve personally verified on macOS with the ChatGPT desktop app. I haven’t tested every piece of desktop state, so I’m deliberately not claiming that every feature behaves identically across providers.</em></blockquote><h3>Back up your configuration first</h3><p>Before changing anything, make a backup of your existing Codex configuration.</p><p>I like using the date and time in the filename so old backups remain meaningful:</p><pre>cp ~/.codex/config.toml ~/.codex/config.toml.backup.$(date +%F-%H%M%S)</pre><p>I’d also back up your .zshrc, since the installer will add a small block to it:</p><pre>cp ~/.zshrc ~/.zshrc.backup.$(date +%F-%H%M%S)</pre><p>You don’t need to copy the whole ~/.codex directory for this. The switcher doesn’t touch your sessions, memories, authentication databases or other Codex state.</p><p>We’ll also make the switcher maintain a rolling safety backup before it modifies config.toml, but that’s different from this manual checkpoint.</p><h3>Install the switcher</h3><p>I’ve put the maintained version of the switcher on GitHub:</p><p><a href="https://github.com/techwithmatheus/codex-account-switcher"><strong>techwithmatheus/codex-account-switcher</strong></a></p><p>Clone the repository:</p><pre>git clone https://github.com/techwithmatheus/codex-account-switcher.git<br>cd codex-account-switcher</pre><p>Then run the installer:</p><pre>bash install.sh</pre><p>I’m deliberately using bash install.sh rather than ./install.sh. That means you don’t have to change executable permissions on the downloaded script first.</p><p>The installer puts the switcher under:</p><pre>~/.config/codex-switcher/<br>├── codex-switcher.zsh<br>└── config</pre><p>and adds a small marked block to ~/.zshrc so zsh loads it whenever you open a shell.</p><p>The actual switching code lives in its own file rather than dumping a large shell function directly into your .zshrc. That makes it much easier to inspect, maintain or replace later.</p><p>After installation, reload your shell:</p><pre>source ~/.zshrc</pre><h3>Configure your Bedrock settings</h3><p>The switcher’s Bedrock-specific settings live in:</p><pre>~/.config/codex-switcher/config</pre><p>The defaults used throughout this series are:</p><pre>CODEX_BEDROCK_MODEL=&quot;openai.gpt-6-astra&quot;<br>CODEX_BEDROCK_PROFILE=&quot;codex-bedrock&quot;<br>CODEX_BEDROCK_REGION=&quot;us-west-2&quot;</pre><figure><img alt="Finder window showing the codex-switcher configuration folder and the config file containing the Amazon Bedrock model, AWS profile and Region settings." src="https://cdn-images-1.medium.com/proxy/0*BN8L0_Umfq2KAZ8Z.png" /></figure><p>If you used different values when configuring Bedrock, update them there.</p><p>For example, if your AWS profile is called work-bedrock:</p><pre>CODEX_BEDROCK_PROFILE=&quot;work-bedrock&quot;</pre><p>The model and Region should likewise match the Bedrock setup you’ve already verified.</p><h4>What if Bedrock is already configured?</h4><p>If you’ve just followed the first article, you may already have Amazon Bedrock active when you install the switcher.</p><p>The installer handles that case too.</p><p>If it finds the standard Bedrock configuration already active, it shows the values it discovered:</p><pre>Existing Amazon Bedrock configuration found.<br>Model:       openai.gpt-6-astra<br>AWS profile: codex-bedrock<br>Region:      us-west-2<br>These provider settings will be adopted by the switcher and will not be replaced.<br>Continue? [Y/n]</pre><p>It then adopts the existing settings rather than creating a duplicate Bedrock provider configuration.</p><p>If you’re starting from your normal personal ChatGPT environment instead, your current Codex configuration is left alone and the switcher starts from there.</p><h3>What the switcher actually changes</h3><p>When Bedrock is active, the tool owns one clearly marked block inside ~/.codex/config.toml:</p><pre># &gt;&gt;&gt; codex-bedrock-switcher &gt;&gt;&gt;<br>model = &quot;openai.gpt-6-astra&quot;<br>model_provider = &quot;amazon-bedrock&quot;<br>[model_providers.amazon-bedrock.aws]<br>profile = &quot;codex-bedrock&quot;<br>region = &quot;us-west-2&quot;<br>wire_api = &quot;responses&quot;<br># &lt;&lt;&lt; codex-bedrock-switcher &lt;&lt;&lt;</pre><p>The values come from the separate switcher configuration file we just looked at.</p><p>Everything outside those markers belongs to Codex, or to you, and the switcher leaves it alone.</p><p>That’s important because the desktop-generated config.toml can contain much more than provider configuration: desktop preferences, plugins, MCP servers, trusted projects and other settings may all live in the same file.</p><p>Replacing the entire file whenever you switch would be unnecessarily risky.</p><p>Before each automated change, the current configuration is also copied to:</p><pre>~/.codex/config.toml.switcher-backup</pre><p>That’s a rolling safety backup. It contains the state immediately before the most recent switch and is intentionally overwritten on later switches.</p><h3>Switch to Amazon Bedrock</h3><p>Once everything is installed and your configuration looks right, run:</p><pre>codex-bedrock</pre><p>The switcher will:</p><ol><li>make a safety backup of your current config.toml;</li><li>add the managed Bedrock block;</li><li>launch the ChatGPT desktop app.</li></ol><p>The rest of your Codex state remains where it was.</p><h3>Switch back to your personal ChatGPT account</h3><p>To go back:</p><pre>codex-personal</pre><p>The switcher removes only the Bedrock block it owns.</p><p>It does <strong>not</strong> insert some handcrafted OpenAI provider configuration in its place.</p><p>That’s deliberate.</p><p>During testing, removing the Bedrock override was enough for the desktop app to return naturally to my personal ChatGPT-backed environment using its existing authentication and defaults.</p><p>So rather than trying to reproduce configuration that Codex already knows how to manage, the switcher simply gets out of the way.</p><p>In my tests, I didn’t need to authenticate again either. My personal ChatGPT login was still available because we had never replaced or deleted the shared Codex authentication state.</p><h3>What if ChatGPT is still running?</h3><p>I didn’t want the switcher modifying config.toml underneath a running desktop application.</p><p>So if ChatGPT is still open when you run either command, you’ll get:</p><figure><img alt="Terminal showing the codex-bedrock command detecting that the ChatGPT desktop app is still running and asking whether it should close the app and continue." src="https://cdn-images-1.medium.com/proxy/0*JA0Uc5rsYhI8mWRL.png" /></figure><p>Answer y and the switcher asks macOS to quit ChatGPT normally, waits until the application has exited, performs the switch and launches it again.</p><p>Anything else cancels the operation.</p><p>The important part here is that it uses the application’s normal quit behaviour rather than abruptly killing the process.</p><h4>Skip the question</h4><p>If you already know you want it to close ChatGPT, use -f or --force:</p><pre>codex-bedrock -f</pre><p>or:</p><pre>codex-personal --force</pre><p>That closes the app automatically and continues with the switch.</p><h3>Do the conversations actually carry across?</h3><p>This was the part I cared about most.</p><p>I created a test conversation while Codex was configured through Amazon Bedrock. In that conversation I had it create a small .NET console application that displayed the date.</p><p>I then switched the desktop app back to my personal ChatGPT environment.</p><p>The conversation was still in the app. I could open it and inspect the generated files in the preview panel.</p><p>I switched back to Bedrock and it remained there as well.</p><p>So at least for the local conversation and generated-file workflow I tested, this gives me what I wanted:</p><pre>Personal ChatGPT<br>        │<br>        ▼<br>same local Codex workspace<br>        ▲<br>        │<br>Amazon Bedrock</pre><p>The conversations aren’t being recreated each time you switch providers. We’re keeping the same local Codex state and changing which provider handles model requests.</p><p>That doesn’t mean the underlying services suddenly share billing, authentication or infrastructure. They don’t.</p><p>What we’re preserving is the local working environment around them.</p><h3>What if I already use another custom provider?</h3><p>Codex can contain definitions for multiple model providers in the same configuration, and the switcher leaves unrelated provider definitions alone.</p><p>However, this utility is <strong>not intended to be a universal provider manager</strong>.</p><p>It specifically manages:</p><pre>Personal ChatGPT / OpenAI<br>            ⇅<br>       Amazon Bedrock</pre><p>If you also use another custom provider, you can continue switching to it using whatever method you already use.</p><p>There is one important behaviour to understand.</p><p>Running:</p><pre>codex-bedrock</pre><p>deliberately makes Bedrock active.</p><p>Running:</p><pre>codex-personal</pre><p>removes the Bedrock override and returns Codex to its normal personal ChatGPT/OpenAI behaviour.</p><p>It does not remember that you previously happened to be using some third provider and restore that provider instead.</p><p>Because of that, if the automatic installer finds an unrelated custom provider currently active, it stops instead of trying to guess what your configuration means.</p><p>You can still install the switcher manually alongside a more complex provider setup. The repository README contains the manual installation steps.</p><p>And if there’s another provider you’d like the switcher to support directly, feel free to <a href="https://github.com/techwithmatheus/codex-account-switcher/issues">open an issue</a>. Pull requests are welcome too.</p><h3>Uninstalling the switcher</h3><p>Run:</p><pre>bash uninstall.sh</pre><p>The slightly interesting part of uninstalling isn’t removing the shell files. It’s deciding which provider should remain configured afterward.</p><p>The uninstaller therefore asks:</p><pre>Removing the switcher means ChatGPT will be left configured for a single provider.<br>Which provider would you like to keep?<br>1) Personal ChatGPT / OpenAI<br>2) Amazon Bedrock<br>3) Cancel</pre><p>If you choose <strong>Personal ChatGPT / OpenAI</strong>, the switcher-managed Bedrock block is removed.</p><p>If you choose <strong>Amazon Bedrock</strong>, the Bedrock settings stay in config.toml, but the switcher’s marker comments are removed. What remains is simply a normal Codex Bedrock configuration like the one from the first article.</p><p>And if you choose <strong>Cancel</strong>, nothing changes.</p><p>One thing the uninstaller deliberately does <strong>not</strong> do is restore some snapshot of config.toml from the day you installed the switcher.</p><p>Your Codex configuration may have legitimately evolved since then with new desktop settings, project permissions, plugins or other configuration. Restoring an old snapshot could wipe changes that have nothing to do with this tool.</p><h3>Why ~/.config?</h3><p>You’ll notice the utility lives under:</p><pre>~/.config/codex-switcher/</pre><p>rather than inside the Codex directory itself.</p><p>~/.config is a common convention in Unix-style command-line environments for user-specific configuration. macOS doesn’t guarantee that the directory already exists, so the installer creates it when necessary.</p><p>I also deliberately keep the utility outside ~/.codex.</p><p>The switcher isn’t part of Codex. It’s a small shell tool that modifies one well-defined part of Codex configuration, and keeping its own code and settings separate makes that boundary clearer.</p><h3>A provider switch, not a second account system</h3><p>There’s one distinction worth finishing on.</p><p>This doesn’t turn Amazon Bedrock into another ChatGPT account.</p><p>Your personal ChatGPT environment and your Bedrock environment are still separate in the ways that matter: authentication, billing and the infrastructure processing the model requests are different.</p><p>What we’ve done is take advantage of the fact that Codex’s local workspace doesn’t need to be discarded just because the active model provider changes.</p><p>For my workflow, that’s considerably more useful than maintaining two completely isolated desktop environments.</p><p>I can keep working in the same Codex setup and choose whether the next part of that work should run through my personal ChatGPT environment or through Amazon Bedrock.</p><p>Until the desktop app has a first-class way to handle that scenario, two shell commands are doing the job nicely.</p><h3>Source code</h3><p>The switcher, installer and uninstaller used in this article are available here:</p><p><a href="https://github.com/techwithmatheus/codex-account-switcher"><strong>techwithmatheus/codex-account-switcher</strong></a></p><p>The repository also contains manual installation instructions, configuration details and notes for people already using other custom providers.</p><p>If Codex changes in a way that affects the switching mechanism, I’ll maintain the implementation there rather than expecting readers to keep copying an old shell snippet forever.</p><p><em>Originally published at </em><a href="https://matheusguimaraes.com/writing/switching-between-your-personal-chatgpt-account-and-amazon-bedrock/"><em>matheusguimaraes.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=93e7ef06a8cc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Set Up the ChatGPT Desktop App with Amazon Bedrock]]></title>
            <link>https://medium.com/@techwithmatheus/how-to-set-up-the-chatgpt-desktop-app-with-amazon-bedrock-b8255deb69f8?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b8255deb69f8</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[amazon-bedrock]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 15:43:10 GMT</pubDate>
            <atom:updated>2026-09-20T15:43:10.931Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JVGN61n7Hj1_IIQRtJHxow.png" /></figure><p>A while ago, I tried setting up the ChatGPT desktop app with Amazon Bedrock on another laptop and, while I eventually got it working, it wasn’t without a few snags.</p><p>Fast-forward to last week, when I got a brand-new, shiny, beautiful MacBook Pro (yes, not a very humble brag! 😆) and realised I regretted not writing a blog about the setup the first time around. It would have been pretty handy to have my own instructions when I needed to do it all again. So here we are.</p><p>What I want is fairly simple: to use Codex in the desktop app while sending its model requests through Amazon Bedrock, using my AWS identity, permissions and billing.</p><p>There is an important detail to call out here. This configuration works with <strong>Codex and Work</strong>, not the regular ChatGPT experience. When the app loads with the Bedrock configuration, the ChatGPT option in the dropdown becomes unavailable and is replaced by Work. It also doesn’t change the provider behind normal conversations on chatgpt.com.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/280/0*UxCNgnUg4b40pDIG.png" /></figure><p><em>With the Bedrock configuration loaded, the desktop app offers Work and Codex but not regular ChatGPT.</em></p><p>Getting everything in place isn’t that difficult, really. Some bits can be a little confusing, though, and I don’t think the official documentation out there does a particularly good job of covering them all or explaining how the pieces fit together.</p><h3>Before getting started</h3><p>For this setup, you need:</p><ul><li>a current version of the Codex desktop app;</li><li>access to an AWS account with Amazon Bedrock enabled;</li><li>permission to invoke the OpenAI model you want to use;</li><li><a href="https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html">AWS CLI v2</a> because you are authenticating through AWS SSO; and</li><li>an AWS Region where the selected model is available.</li></ul><p>I’m using openai.gpt-6-astra as the model. Supported models and minimum app versions can change, so it is worth checking the <a href="https://help.openai.com/en/articles/20001253-configure-codex-with-amazon-bedrock">OpenAI Bedrock configuration guide</a> before following the same setup.</p><h3>1. Giving Bedrock its own AWS profile</h3><p>I don’t want Codex quietly depending on whichever AWS profile happens to be the default on my machine, so I create a named profile specifically for this setup. This keeps the configuration explicit, makes it easier to maintain and reduces the risk of a future change to the default profile breaking the Codex integration.</p><p>First, I start the AWS SSO configuration wizard with:</p><pre>aws configure sso</pre><p>The wizard asks for several values:</p><ul><li>an SSO session name;</li><li>your SSO start URL;</li><li>the AWS Region that hosts IAM Identity Center;</li><li>the AWS account and role you want to use;</li><li>the default AWS Region for the profile; and</li><li>a profile name.</li></ul><p>If you’re not familiar with it, the <strong>SSO session name</strong> can sound a little confusing. It is simply a local name for the IAM Identity Center session used to authenticate. Multiple AWS profiles can reuse the same SSO session while pointing to different accounts, roles or default Regions.</p><p>Let’s call the SSO session:</p><pre>amazon-sso</pre><p>And the AWS profile:</p><pre>codex-bedrock</pre><p>For the default client Region, I’m going to choose a Region where the OpenAI model is available. I use us-west-2 in the examples below, but this is one of those values you shouldn&#39;t copy blindly if your AWS environment uses a different Region.</p><p>I follow the steps and, once the profile is created, I sign in with:</p><pre>aws sso login --profile codex-bedrock</pre><p>This opens the browser so I can complete the login. I then check which AWS identity the new profile resolves to:</p><pre>aws sts get-caller-identity --profile codex-bedrock</pre><p>If everything is working, the command returns a JSON response containing the account, user ID and ARN for the selected identity. If it cannot use the profile, you will see a credentials, profile or SSO-related error instead. A successful response confirms that the profile points where I expect it to before I involve Bedrock or Codex.</p><h3>2. Checking the model is available in the right Region</h3><p>Before touching the Codex configuration, you should check whether the model you want to use is available in the same Region you configured in your profile. The model I want is:</p><pre>openai.gpt-6-astra</pre><p>And the Region in the codex-bedrock profile I just set up is:</p><pre>us-west-2</pre><p>I could use the Amazon Bedrock console to check, or I can just run the following command from Terminal:</p><pre>aws bedrock list-foundation-models \<br>  --by-provider OpenAI \<br>  --region us-west-2 \<br>  --profile codex-bedrock</pre><p>This shows me the OpenAI models available through my SSO profile in us-west-2, based on the permissions attached to the role I selected. I can see that openai.gpt-6-astra is available, so I&#39;m good to proceed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/0*fzDVvv8YKsO_wQG2.png" /></figure><p><em>Confirming that GPT-6 Astra is available through the SSO profile in us-west-2.</em></p><p>Foundation models should be available in Bedrock by default when the required permissions are in place. With third-party models, however, Bedrock may start the subscription process in the background the first time you invoke one, and that can take a few minutes. In a centrally managed AWS account, an administrator may also need to enable the model or grant the required Marketplace and Bedrock permissions.</p><h3>3. Editing the Codex configuration without losing what’s already there</h3><p>Here is where we need to be a bit more careful. The desktop app has already populated its configuration with desktop settings, plugins and local tooling, so replacing the whole file with a minimal example would throw away configuration we want to keep.</p><p>Codex reads its local configuration from:</p><pre>~/.codex/config.toml</pre><p>If the directory does not exist yet, create it with:</p><pre>mkdir -p ~/.codex</pre><p>Because my config.toml already exists, I make a backup before changing anything:</p><pre>cp ~/.codex/config.toml ~/.codex/config.toml.backup</pre><p>Codex loads the file named config.toml, so the .backup copy is there if I need it without being treated as the active configuration.</p><p>I then open the configuration in Kiro:</p><pre>open -a &quot;Kiro&quot; ~/.codex/config.toml</pre><p>If you would rather stay in Terminal, nano works too, of course:</p><pre>nano ~/.codex/config.toml</pre><p>The code that we need to add it the following:</p><pre>model = &quot;openai.gpt-6-astra&quot;<br>model_provider = &quot;amazon-bedrock&quot;</pre><pre>[model_providers.amazon-bedrock.aws]<br>profile = &quot;codex-bedrock&quot;<br>region = &quot;us-west-2&quot;<br>wire_api = &quot;responses&quot;</pre><p>If your file already contains model or model_provider, update those values rather than adding the same keys twice.</p><p>There are three values worth checking before saving:</p><ul><li>model is an exact model ID supported by the current Codex and Bedrock integration. In my case, I&#39;m using astra but you pick what you prefer, of course;</li><li>profile matches the named AWS profile you created earlier; and</li><li>region matches the Region in which that model is available.</li></ul><p>I choose to set the AWS profile directly in config.toml. That makes the dependency explicit and avoids relying on the desktop app to inherit environment variables from my shell, which desktop applications do not always do.</p><p>By the way, be careful where you add the snippet on config.toml because placement matters. Not because Codex requires the sections in a particular visual order, but because TOML uses section headings to determine which settings belong together.</p><p>In the configuration created by my desktop app, the file begins with a notify setting followed by the [desktop] section. I keep the existing notify line unchanged and insert the Bedrock block <strong>immediately before </strong><strong>[desktop]</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*k-xfiWMhxoiuIM7R.png" /></figure><p><em>The Bedrock settings go after the existing top-level values and immediately before </em><em>[desktop].</em></p><h3>4. Restarting the desktop app</h3><p>This is an easy step to overlook. After saving the file, I quit the desktop app completely and open it again. Editing config.toml while the app is running does not force the current process to reload the provider configuration.</p><p>Once the app reopens, I start a new Codex session.</p><h3>5. Proving that Codex is actually using Bedrock</h3><p>I don’t want to treat “Codex answered me” as proof that the setup works. A successful response only proves that <em>some</em> provider handled the request.</p><p>To check the provider directly, I start a Codex CLI session and open:</p><pre>/status</pre><p>The model provider should be:</p><pre>amazon-bedrock</pre><p>I also confirm that Astra is the selected model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*8HHOn0msExapdfeV.png" /></figure><p><em>The status output provides a direct check that Codex is using Amazon Bedrock.</em></p><p>Finally, I send a small test prompt through the desktop app. I deliberately use something that exercises Codex without involving one of my real codebases yet:</p><pre>Create a small C# console application that prints the current UTC time, and explain each file you create.</pre><p>Once that completes and /status shows amazon-bedrock, I know the local Codex setup is genuinely sending its requests through Bedrock.</p><h3>If it doesn’t work…</h3><p>Once you split the setup into AWS authentication, Bedrock model access and the local Codex configuration, most failures become much easier to narrow down. These are the checks I would make first.</p><h3>aws is not found</h3><p>AWS CLI is either not installed or is not available on your shell’s PATH. Install AWS CLI v2, open a new Terminal window and run aws --version again.</p><h3>The SSO session has expired</h3><p>Authenticate again:</p><pre>aws sso login --profile codex-bedrock</pre><p>Then restart the desktop app if the current session does not recover.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*0WqFZzmfR3gG1ay2.png" /></figure><p><em>An expired AWS SSO session may appear as a less obvious provider error in the desktop app.</em></p><h3>Codex cannot find the AWS profile</h3><p>Check that the profile exists:</p><pre>aws configure list-profiles</pre><p>Then make sure the spelling in config.toml matches it exactly.</p><h3>The model ID is rejected</h3><p>Model IDs must match one of the values currently supported by the Codex and Bedrock integration. Do not assume that every model visible in the Bedrock catalog is supported by Codex, and do not shorten the model ID.</p><h3>You receive AccessDeniedException</h3><p>Check all three layers:</p><ol><li>the AWS profile resolves to the identity you expected;</li><li>that identity has permission to invoke the model in Amazon Bedrock; and</li><li>the model is available to the account in the selected Region.</li></ol><p>On first use of a third-party model, Bedrock may still be completing its subscription process. If permissions are correct, wait a few minutes and try again. In an organisation-managed AWS account, you may need the account administrator to enable the model or update your permissions.</p><h3>The desktop app still uses the previous provider</h3><p>Check that you edited ~/.codex/config.toml, saved the file and completely restarted the app. If you are using environment-variable-based AWS authentication instead of a named profile, remember that the desktop app may not inherit variables exported only in Terminal; OpenAI recommends putting required desktop-app variables in ~/.codex/.env.</p><h3>An unexpected Bedrock API key is being used</h3><p>Codex checks AWS_BEARER_TOKEN_BEDROCK before the AWS SDK credential chain. If that variable contains an old or unintended key, it takes precedence over your named AWS profile. Remove or correct it, then restart Codex.</p><h3>What actually changes?</h3><p>With model_provider = &quot;amazon-bedrock&quot;, my local Codex setup authenticates with AWS and sends model requests through Amazon Bedrock’s implementation of the Responses API. The OpenAI-hosted API is not in that request path.</p><h3>Not every feature is supported</h3><p>The unavailable ChatGPT option is the most immediately visible difference, but it isn’t the only one. The Bedrock-backed experience does not necessarily include every feature available when Codex is backed by ChatGPT. OpenAI’s documentation lists limitations including image generation, voice transcription, the cloud plugin store, cloud configuration and policies, and cloud agents. Feature support can change, so I would check the documentation rather than treating that as a permanent list.</p><p>There is another limitation I wasn’t expecting. Even with amazon-bedrock shown as the active provider, I still reached the ChatGPT desktop app&#39;s standard usage limit. In other words, using Bedrock changes where the model request goes and where that usage is billed, but it does not necessarily make the desktop experience unlimited, which is surprising, but a topic for another day.</p><h3>Switching between different accounts</h3><p>At this point, I have Bedrock working on the new Mac. But I have also replaced the configuration used by my personal ChatGPT-backed setup, which brings me straight to the next practical problem: how do I use both without manually editing config.toml every time?</p><p>That is what I’ll cover in the second post in this series, where I’ll show how I keep the two environments separate and use simple shell commands to switch between them.</p><h3>Further reading</h3><ul><li><a href="https://help.openai.com/en/articles/20001253-configure-codex-with-amazon-bedrock">Configure Codex with Amazon Bedrock: OpenAI</a></li><li><a href="https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html">Amazon Bedrock quickstart: AWS</a></li><li><a href="https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html">Configure IAM Identity Center authentication with AWS CLI: AWS</a></li><li><a href="https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html">Request access to Amazon Bedrock models: AWS</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8255deb69f8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI in Games: Are We Drawing the Line in the Wrong Place?]]></title>
            <link>https://medium.com/@techwithmatheus/ai-in-games-are-we-drawing-the-line-in-the-wrong-place-2ef8cf238786?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ef8cf238786</guid>
            <category><![CDATA[ai-ethics]]></category>
            <category><![CDATA[gaming]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 14:02:23 GMT</pubDate>
            <atom:updated>2026-09-02T14:02:23.074Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EUdroQdJUbgfd3HzrsUkag.png" /></figure><p>The games industry is going through an uncomfortable transition. Studios see the productivity gains AI may offer, while many players see almost any use of it as inherently bad. As a lifelong gamer who started his career as a game developer, I see that divide from both sides.</p><p>I understand the reaction. People are worried about artists losing work, creative jobs being devalued and models being trained on work without permission. Those concerns certainly deserve careful consideration, but I also think the conversation has become far too binary with outright rejection often treated as the only acceptable position.</p><h3>When any use becomes unacceptable</h3><p>The example that crystallised this for me was <em>Clair Obscur: Expedition 33</em>. The <a href="https://uk.pcmag.com/ai/162208/clair-obscur-expedition-33-stripped-of-a-game-of-the-year-award-because-of-ai">Indie Game Awards withdrew its Game of the Year and Debut Game awards </a>after it emerged that generative AI had been used during production. The material appears to have been placeholder artwork that accidentally shipped and was later patched out.</p><p>There is a disclosure issue. The awards had a clear rule, and the submission reportedly stated that no generative AI had been used so, ok, I understand it from the perspective of enforcing that rule.</p><p>What I disagree with is the rule itself. Declaring a game ineligible because generative AI touched any part of production, regardless of how it was used, feels very extreme and, dare I say, very naive and counterproductive to me. It turns “AI was involved” into the entire judgement and ignores context, scale and impact.</p><h3>We have seen this pattern before</h3><p>When Disney blended computer-generated environments with hand-drawn characters in <em>Beauty and the Beast</em>, audiences marvelled. CGI transformed visual effects, and computer animation became an art form of its own. We did not judge those works by how many people might have recreated every frame by hand. In fact, <em>Toy Story</em>, released in 1995 as the first fully computer-animated feature film, continues to be celebrated today.</p><p>To me, AI is just another step in that long history of automation. Game development already depends on IDEs, automated testing, procedural generation, motion capture, physics engines and infrastructure that scales itself. All allow teams to do more. If replacing manual effort is the line we object to, where does that line begin?</p><p>That is not to say that every use of AI is ethical, of course. Replacing an actor’s performance without consent is not the same as generating an environmental texture. Eliminating a creative team is not the same as helping one automate repetitive work. Training data, consent, attribution, disclosure and the treatment of workers matter.</p><p>That is why I find blanket rejection, at the very least, unhelpful. It removes the nuance needed to tell responsible use from exploitative use.</p><h3>Judge the outcome, and ask better questions</h3><p>As a gamer, I care most about the game: Is it good? Is it original? Does it move me?</p><p>If we want to examine how it was made then we should go deeper than just “AI was used.” What was it used for? Did it replace credited work? Was source material used with permission? Did the studio mislead anyone? Did the tool help creators realise their vision, or flatten it?</p><p>I know this is a topic that probably deserves a whole post in itself, but I also feel similarly about AI-generated art.</p><p>Art communicates, provokes or makes us feel.</p><p>The creation process can affect how we value a work. I personally struggle to appreciate works created by simply throwing paint at a canvas, for example, but my reaction to that process does not necessarily mean the result isn’t art. Similarly, I do not believe that using a prompt automatically prevents the result from being art, any more than using a camera, graphics tablet, image editor, particle system or CGI package does.</p><p>My bet is that AI will become another ordinary part of how games are made and the current backlash is just a transitional state of mind while society works out the boundaries of a disruptive technology and adjusts to a new world.</p><p>We should absolutely shape those boundaries, but I hope we shape them around consent, transparency and harm, not fear of the technology itself.</p><p>Of course, that’s just my perspective, not a universal answer. Where would you draw the line? Which uses of AI in game development do you consider acceptable, and which do you not? I would genuinely like to hear how players and developers see it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ef8cf238786" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running Kiro Crew in Docker on Windows]]></title>
            <link>https://medium.com/codex/running-kiro-crew-in-docker-on-windows-e64edc27bdf0?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e64edc27bdf0</guid>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[windows]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 21:36:01 GMT</pubDate>
            <atom:updated>2026-08-31T21:36:01.132Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hdihvIo_Pt8tkk9QBNrncQ.png" /></figure><p>I’ve been playing with <a href="https://kiro.dev/blog/introducing-kiro-crew/">Kiro Crew</a> recently, and when I went to get it running on my Windows machine I had a decision to make.</p><p>Kiro Crew doesn’t currently have a Windows desktop app. You can still run it natively on Windows, but the documented route involves installing and running the Gateway from source.</p><p>But then, while looking through the <a href="https://github.com/kirodotdev/KiroCrew">Kiro Crew GitHub repository</a>, I noticed another option that immediately caught my attention: <strong>there’s an </strong><a href="https://github.com/kirodotdev/KiroCrew/blob/main/docs/guides/docker.md"><strong>official Docker image</strong></a><strong>.</strong></p><p>Docker is already a familiar part of the development workflow for many of us, and a container felt like a nice, clean way to get Kiro Crew running without installing it from source.</p><p>So that’s the route I took.</p><p>It worked, but along the way I ran into an interesting security detail that made the setup slightly less straightforward than simply running a container.</p><p>And, as it turns out, that’s actually a good thing.</p><h3>What we’re going to do</h3><p>By the end of this post, we’ll have Kiro Crew running in Docker on Windows, with its agent sandbox enabled and without giving the container more privileges than it actually needs.</p><p>I’m using Docker Desktop with WSL 2, so you’ll want to have those installed before following along.</p><p>You can check your WSL installation with:</p><pre>wsl --version</pre><p>With that out of the way, let’s get Kiro Crew running.</p><h3>Starting with the official container image</h3><p>The Kiro Crew team publishes a public container image, so we don’t need to build anything ourselves or even authenticate with a container registry. Nice and easy.</p><p>Before doing anything else, I created a directory to keep the files for this setup together:</p><pre>mkdir kiro-crew<br>cd kiro-crew</pre><p>Now, at first glance, running Kiro Crew looks like it should be as simple as starting the official image.</p><p>And technically, the Gateway itself will run.</p><p>But there’s another security boundary inside that container that we need to understand before we can start it properly.</p><h3>Wait… a sandbox inside a container?</h3><p>This was the interesting part for me.</p><p>We’re already putting Kiro Crew inside a Docker container, which gives us an isolation boundary between Kiro Crew and our Windows host.</p><p>But Kiro Crew adds another boundary of its own.</p><p>Agent commands aren’t simply executed with access to everything available to the main Kiro Crew process. On Linux, Kiro Crew creates an internal user-namespace sandbox for those commands.</p><p>Conceptually, our setup looks something like this:</p><pre>Windows<br>└── Docker container<br>    └── Kiro Crew<br>        └── Agent sandbox</pre><p>Why sandbox an agent that’s already inside a container?</p><p>Because the two boundaries are protecting different things.</p><p>The container isolates Kiro Crew from our host. The inner sandbox isolates <strong>agent commands from sensitive state available to Kiro Crew itself</strong>.</p><p>For example, Kiro Crew’s sandbox hides credential directories such as ~/.aws and ~/.ssh from agent subprocesses by bind-mounting empty directories over them. So if an agent-executed command tries to access one of those directories, it simply sees an empty directory rather than our AWS credentials or SSH keys.</p><p>That means the Gateway can have the credentials it needs to do its job without automatically making those credentials readable by commands executed by an agent.</p><p>That’s a pretty important distinction when we’re giving an AI agent the ability to execute commands.</p><h3>Where Docker gets in the way</h3><p>There’s one complication.</p><p>To create that inner sandbox, Kiro Crew needs Linux system calls including:</p><pre>unshare(CLONE_NEWUSER)<br>unshare(CLONE_NEWNS)</pre><p>Docker’s default seccomp security policy blocks those operations.</p><p>So if the Kiro Crew container can’t create its inner sandbox, it doesn’t quietly shrug its shoulders and run agent commands without one.</p><p>It <strong>fails closed</strong>, meaning that when the security mechanism can’t be established, access is denied rather than silently falling back to a less secure mode.</p><p>The Gateway and dashboard can still run, but agent command execution remains disabled.</p><p>I actually really like this design! What initially looks like an extra hurdle in getting the container running is Kiro Crew refusing to silently weaken its security model.</p><p>So how do we fix it?</p><h3>The tempting solution and the better solution</h3><p>There are a few ways we could approach this.</p><p>One option is to simply tell Kiro Crew that we accept running agent commands without the inner sandbox. Kiro Crew provides an environment variable for exactly that:</p><pre>KIROCREW_ALLOW_UNSANDBOXED=1</pre><p>We could pass that into our container and Kiro Crew would allow agent execution, leaving Docker itself as our only isolation boundary.</p><p>We could also reach for the rather large hammer:</p><pre>--privileged</pre><p>That would make the sandbox work, but it does so by granting the container extremely broad privileges and removing many of Docker’s normal isolation restrictions.</p><p>That’s a much bigger security concession than we actually need.</p><p>What we really want is much narrower:</p><p><strong>Allow the operations Kiro Crew needs to create its sandbox while keeping the rest of Docker’s security restrictions in place.</strong></p><p>And this is another nice detail about the Kiro Crew implementation: the team already provides a seccomp profile specifically for this!</p><p>So we don’t have to create one ourselves.</p><h3>Downloading the Kiro Crew seccomp profile</h3><p>From the kiro-crew directory we created earlier, download the <a href="https://github.com/kirodotdev/KiroCrew/blob/main/docker/seccomp/kirocrew-seccomp.json">official Kiro Crew seccomp profile</a>:</p><pre>curl -fsSL https://raw.githubusercontent.com/kirodotdev/KiroCrew/main/docker/seccomp/kirocrew-seccomp.json \<br>  -o kirocrew-seccomp.json</pre><p>You should now have:</p><pre>kiro-crew/<br>└── kirocrew-seccomp.json</pre><blockquote><strong><em>Having trouble downloading it from WSL?</em></strong></blockquote><blockquote><em>I happened to be dealing with a DNS issue in my WSL environment when I did this, so </em><em>curl couldn&#39;t resolve GitHub. If you happen to run into the same thing, there&#39;s nothing special about downloading the file through </em><em>curl: you can download </em><em>kirocrew-seccomp.json directly from the Kiro Crew GitHub repository in your browser and place it in this directory manually, which is what I did.</em></blockquote><p>Now we can start the container using that profile.</p><h3>Running Kiro Crew</h3><p>Run:</p><pre>docker run -d --name kirocrew \<br>  -p 127.0.0.1:5476:5476 \<br>  -v kirocrew-home:/home/kirocrew \<br>  --security-opt seccomp=kirocrew-seccomp.json \<br>  ghcr.io/kirodotdev/kirocrew:stable</pre><p>There are a couple of things worth noticing here.</p><p>We’re only publishing port 5476 on the host&#39;s loopback interface, so the dashboard isn&#39;t being exposed to the rest of our network.</p><p>We’re also creating a named Docker volume:</p><pre>kirocrew-home</pre><p>Kiro Crew keeps its persistent state under /home/kirocrew, including its configuration and Kiro CLI credentials. That means our state can survive replacing or upgrading the container.</p><p>And, most importantly for what we’ve just discussed, we’re passing the Kiro Crew seccomp profile with:</p><pre>--security-opt seccomp=kirocrew-seccomp.json</pre><p>The container can now create the inner namespace sandbox while Docker’s other default security restrictions remain in place.</p><h3>Let’s open it</h3><p>At this point I did what I imagine most developers would do.</p><p>I opened:</p><pre>http://localhost:5476</pre><p>And instead of the Kiro Crew dashboard, I was greeted by a message telling me I was missing a token.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRccppXaMbY8xC3Q78ocJw.png" /></figure><p>Another security measure!</p><p>Simply being able to reach port 5476 isn&#39;t enough to get access to the dashboard. Kiro Crew also requires a bearer token, so someone who can reach the Gateway still needs to authenticate before they can use it.</p><p>So, there’s one more part of the setup we need to do.</p><p>Actually, two.</p><h3>Authenticating Kiro CLI</h3><p>Kiro Crew’s agent runtime uses kiro-cli, so first we need to authenticate the CLI running inside our container.</p><p>We can do that without opening an interactive shell ourselves:</p><pre>docker exec -it kirocrew kiro-cli login</pre><p>Follow the authentication flow and log in with the identity you use for Kiro.</p><p>Once authentication succeeds, those credentials are stored in the kirocrew-home volume we created earlier, so they survive container upgrades.</p><p>But that authenticates the agent runtime.</p><p>We still need access to the dashboard.</p><h3>Getting our dashboard token</h3><p>Every request to the Kiro Crew dashboard requires a token.</p><p>We can mint a temporary login link from the running container:</p><pre>docker exec kirocrew kirocrew token --ttl 2h</pre><p>Kiro Crew will print a URL containing the token.</p><p>It will look roughly like:</p><pre>http://localhost:5476/?token=...</pre><p>Open that URL in your browser and…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qP91QKtEoYpbwGj_1gGIFA.png" /></figure><p><strong>We’re in!</strong></p><p>And with that, we have Kiro Crew running nicely inside Docker on Windows, without having to build it from source and without unnecessarily weakening either of its isolation boundaries.</p><p>Now I just need someone to explain why the Solarized theme is green instead of yellow. 😄</p><h3>References</h3><ul><li><a href="https://kiro.dev/docs/crew/installation/">Kiro Crew installation documentation</a></li><li><a href="https://github.com/kirodotdev/KiroCrew">Kiro Crew GitHub repository</a></li><li><a href="https://github.com/kirodotdev/KiroCrew/blob/main/docs/guides/docker.md">Kiro Crew Docker guide</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e64edc27bdf0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/running-kiro-crew-in-docker-on-windows-e64edc27bdf0">Running Kiro Crew in Docker on Windows</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Can’t We Just Use Claude for Everything? Agent Creation vs. Agent Engineering]]></title>
            <link>https://medium.com/@techwithmatheus/why-cant-we-just-use-claude-for-everything-agent-creation-vs-agent-engineering-2c22310f3c0d?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c22310f3c0d</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[agents]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 16:45:41 GMT</pubDate>
            <atom:updated>2026-08-18T16:45:41.369Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v3Zx6SCfnowkv0tPblvwlQ.png" /></figure><p>Recently, I was talking to a friend who, much like the rest of the world, has started using AI extensively at work to create agents even though she’s not a software developer or from a technical background.</p><p>She has been experimenting with Claude a lot, building useful workflows for herself and her team, and getting increasingly excited about what these systems can do.</p><p>At some point, our conversation moved onto the work I’ve been doing around agentic systems: agent architectures, context engineering, memory, orchestration, sub-agents and frameworks such as Strands Agents.</p><p>And her reaction was:</p><p><strong>Why do you need all of that? I’m already creating agents.</strong></p><p>“Great question”, I thought to myself.</p><p>And what made it particularly interesting was that I’d heard almost the same question from the opposite direction.</p><p>After giving a talk about agentic architecture and building harnesses with Strands Agents SDK, a junior developer came up to me and asked:</p><p><strong>What’s the point of all of this? Why can’t we just use Claude for everything?</strong></p><p>Two people approaching the subject from completely different directions had arrived at the same question.</p><p>And I think that question exposes something important about where we are with agents today. We are using the same word <strong>“agent”</strong> to describe two very different activities with very different use cases.</p><p>The way I see it, there is a big difference between <strong>creating agents</strong> and <strong>engineering agents</strong>.</p><h3>Agent Creation vs. Agent Engineering</h3><p>Applications such as Claude, ChatGPT, Amazon Quick and others increasingly allow people to create surprisingly sophisticated agentic workflows without building the underlying infrastructure themselves.</p><p>There is still a learning curve, though. You need to provide instructions and give the system knowledge and context in a way that produces results that are within expectation (and, hopefully, without hallucinations!). You may also need to learn about tools, set up integrations, schedule work or even create subagents so multiple pieces of functionality can work together.</p><p>From the user’s perspective, they have created an agent. And indeed they have! But when a software engineer looks at the same system… they see something different.</p><p>They see an application providing a highly abstracted, opinionated agent runtime operating as a black box. You have little control over how execution happens, how context is assembled and maintained, how the system scales, or even where memory lives, among other architectural concerns.</p><p>As an application user, you are creating an agent <strong>inside somebody else’s agentic architecture</strong>.</p><p>And that’s not a problem. In fact, this could be exactly what you need!</p><p>Developers and software architects make trade-offs between abstraction and control all the time. We don’t choose the lowest-level technology simply because it gives us the most control; we use abstractions because they remove decisions we don’t want to make and complexity we don’t need to own.</p><p>The same principle applies here. If Claude gives you everything you need to create an agent, why <em>wouldn’t</em> you use it?</p><p>As usual with system design, the important thing is understanding the trade-offs. The abstraction works because somebody else has made a set of architectural decisions for you. If those decisions suit your requirements, then awesome. If they don’t, you may need to take ownership of some of them yourself.</p><p>That’s where I find the distinction between <strong>Agent Creation</strong> and <strong>Agent Engineering</strong> useful.</p><p>For me, three things make that distinction particularly clear.</p><h3>Is the agent a feature or a component?</h3><p>This is perhaps my favourite way of thinking about the distinction.</p><p>Let’s say I create an agent in Claude to research holidays for me. It knows my preferences, researches destinations, compares options and perhaps uses tools to build an itinerary. It could be incredibly sophisticated… but Claude is still the application. I go to Claude, interact through Claude’s interface and rely on Claude’s infrastructure to make everything work.</p><p>My agent is a <strong>feature of an application I’m using</strong>.</p><p>Now imagine I want to offer that same experience through my own travel website. A customer comes to my application and asks for a holiday; somewhere behind the scenes an agent researches flights and hotels, applies their preferences, interacts with booking systems and returns the result.</p><p>The capability sounds almost identical, but architecturally something fundamental has changed. The agent is now a <strong>component of a system I’m building</strong>.</p><p>Suddenly I need to decide where it runs, how my application communicates with it, how it scales, how it authenticates against other systems, what happens when it fails, how it fits into traditional application flows, and how I observe what it’s doing. The AI is no longer the destination; it’s now part of the system I’m responsible for.</p><p>That’s very clearly Agent Engineering.</p><p>The point is really about ownership. If an agent is a feature of Claude or another application, you’re limited, quite deliberately, to what that application allows you to do. If your requirements fit inside those boundaries, great. When they don’t… you need another abstraction.</p><h3>Do you need control over the economics?</h3><p>Another reason you might choose to engineer the agent is cost.</p><p>There is a lot of conversation right now about just how many tokens agentic systems can consume, particularly as we build long-running workflows with large context windows, tool calls and multiple agents.</p><p>Moving from Agent Creation to Agent Engineering doesn’t automatically make any of this cheaper, by the way. Engineering has its own cost, and it would be rather ironic to spend £100,000 in developer time to save £500 in tokens.</p><p>What engineering gives you is <strong>control</strong>.</p><p>If you own the harness around your agents, architectural decisions become available that simply aren’t exposed when you’re operating inside somebody else’s application.</p><p>You can decide that one task doesn’t need the full conversation history, cache an expensive result, retrieve memory only when it’s relevant, summarize context between steps, or route simpler tasks to cheaper models.</p><p>You can start treating context and tokens as resources that you deliberately engineer.</p><p>There’s a much larger conversation here around context engineering, but that’s a story for another post. For now, the important point is that <strong>the abstraction determines which levers are available to you</strong>.</p><p>If you don’t need those levers, there’s little value in taking responsibility for them. If the economics of your system mean you do, Agent Engineering gives you that control.</p><h3>Do you need to own where your data goes?</h3><p>Then there is a question that tends to become important very quickly in enterprise environments: where does everything actually live?</p><p>When I create an agent inside an application, I’m accepting that application’s architecture and its mechanisms for handling context, state, memory, integrations and data. Again, that may be completely acceptable.</p><p>But what if particular data cannot leave a certain environment? What if I need to know exactly where long-term memory is persisted, control which model receives which information, maintain my own audit trail, or guarantee that certain data never crosses a particular boundary?</p><p>Now the black box really matters.</p><p>This is partly a compliance question, partly a data ownership question and, yes, partly a vendor lock-in question. The more behaviour, knowledge and state I build around one application’s abstractions, the more dependent I become on that platform’s capabilities and constraints.</p><p>But vendor lock-in isn’t, by itself, a reason to engineer everything from scratch. We accept varying degrees of lock-in throughout modern software architecture because managed abstractions can provide enormous value.</p><p>The question is simply whether that trade-off is acceptable <strong>for the requirements in front of you</strong>.</p><h3>So… Can’t We Just Use Claude For Everything?</h3><p>A useful spreadsheet can eventually become an application, but that doesn’t mean the spreadsheet was a mistake. It may have been exactly the right abstraction for the problem at the time, and it may even have helped us understand the problem well enough to know what was worth engineering later.</p><p>I think Agent Creation and Agent Engineering should be seen in much the same way: not as levels on a maturity ladder, and certainly not as a journey where every agent should eventually become an engineered one, but as different architectural choices about how much of the underlying system we need to own. We might happily create an agent inside Claude for one task while engineering another from the ground up, perhaps even within the same system.</p><p>Sometimes an agent created inside Claude, ChatGPT, Amazon Quick or another application will remain there because it does everything we need. Sometimes our requirements will mean taking ownership of the architecture ourselves and we’ll find ourselves reaching for Strands Agents SDK or another agent harness.</p><p>And perhaps the next time someone asks me, <em>“Why can’t I just use Claude for everything?”</em>, my answer will simply be…</p><p><strong>You can! For as long as its decisions are compatible with yours.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c22310f3c0d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monolith vs Microservices: Why This Debate Never Ends]]></title>
            <link>https://medium.com/@techwithmatheus/monolith-vs-microservices-why-this-debate-never-ends-d782297d28fa?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/d782297d28fa</guid>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[monolithic-architecture]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 08:01:02 GMT</pubDate>
            <atom:updated>2026-03-04T08:01:02.265Z</atom:updated>
            <content:encoded><![CDATA[<p>The monolith vs microservices debate refuses to die.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WiTOoJtd_2twG7iyT9rmcg.png" /></figure><p>Every few months it resurfaces in a slightly different form. Actually, to date, I still get invited to take part in panels discussing it, and what strikes me each time is how familiar the arguments sound. The framing may evolve, the tooling certainly changes, but the core tensions are remarkably similar to the ones we were debating over a decade ago.</p><p>Some argue that “serious systems” must be built with microservices. Others counter that monoliths are “making a comeback”. Even online, you see comment sections fill up with strong opinions and the conversation quickly becomes polarized.</p><p>The reason this debate never ends is not because one side keeps winning. It is because both sides are pointing at something real.</p><p>A monolith is not inherently outdated. And microservices are not inherently modern. The real question is not which one is better in theory. <strong>The real question is whether</strong> <strong>the architectural choice was intentional</strong>.</p><p>There is a fundamental difference between an old-school ball of mud and what I would call a modern monolith.</p><p>The ball of mud is <strong>definitely </strong>not a strategy. It is what happens when boundaries are never defined, when everything depends on everything else, and when the database becomes a shared integration layer. Over time, changes begin to ripple unpredictably across the system. Teams slow down, deployments become risky, and the architecture starts working against the business rather than enabling it.</p><p>That situation is not a monolith as an architectural decision. It is accumulated architectural debt.</p><p>If you are sitting on one of those systems, the problem is not simply aesthetic. It is structural. It should trigger a serious conversation about boundaries, ownership, and long-term direction. Whether the path forward leads to a modular monolith or to microservices is a secondary question. The first priority is restoring clarity and separation of concerns.</p><p>A modular monolith, by contrast, is a deliberate design.</p><p>When modules have clear boundaries, explicit contracts, and enforced dependency rules, the system retains operational simplicity while gaining architectural structure. For many greenfield systems, this is a highly balanced starting point. You can move quickly, deliver business value, and avoid the distributed complexity that microservices inevitably introduce. At the same time, you are future-proofing your application for a possible evolution towards distributed architecture if and when needed.</p><p>If growth or organizational scaling later demands service decomposition, the transition is far more organic. You are not escaping chaos. You are then simply extending an architecture that was already structured around boundaries. It is no coincidence that we are even seeing native framework support for this approach in some ecosystems, such as Spring Modulith in the Java world, which explicitly facilitates the modular monolith design as a first-class architectural choice.</p><p>My take on it? If you have a greenfield project, start with a modular monolith. Not as a temporary compromise, and not as a defensive posture against microservices, but as a conscious architectural choice that balances delivery speed with long-term adaptability.</p><p>Microservices absolutely solve real problems. They shine when independent deployment, team autonomy, and operational isolation become first-order concerns. But they also introduce new constraints, new failure modes, and a level of distributed systems complexity that should not be underestimated.</p><p>The real mistake is not choosing monolith or microservices.</p><p>The real mistake is choosing either one reactively, without understanding the context in which both the system and the organization operate.</p><p>Architecture is not a troubleshooting technique. It is a design discipline. And discipline can exist in a monolith or in a microservices landscape.</p><p>The absence of it, however, will break both.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d782297d28fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Queues Don’t Magically Remove Failure]]></title>
            <link>https://medium.com/@techwithmatheus/queues-dont-magically-remove-failure-ddb6a1113a37?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/ddb6a1113a37</guid>
            <category><![CDATA[message-queue]]></category>
            <category><![CDATA[system-reliability]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Wed, 11 Feb 2026 08:01:03 GMT</pubDate>
            <atom:updated>2026-02-11T08:01:03.311Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cEDq_Zj9fPEEe-XnNXjXuw.png" /></figure><p>Message queues are often introduced with the best of intentions. Teams want to reduce synchronous dependencies, absorb traffic spikes, and make systems more resilient in the face of partial failure.</p><p>In many cases, queues are exactly the right tool.</p><p>The problem starts when the presence of a queue creates an illusion of safety. Once communication becomes asynchronous, failures stop being immediate and visible, and it becomes tempting to assume that the system is now inherently resilient.</p><p>That assumption is where things tend to go wrong.</p><p>Queues do not remove failure from a system. They change how failure manifests, when it becomes visible, and how costly it is to recover from.</p><p><strong>Deferred failure and the illusion of safety</strong></p><p>In a synchronous interaction, failure is explicit. If a downstream service is unavailable or a request times out, the caller experiences the failure directly. That kind of failure is noisy, but it is obvious and relatively easy to reason about.</p><p>When a queue is introduced, the failure path changes. The producer successfully publishes a message and continues processing, while the actual work is deferred. As far as the caller is concerned, everything is fine and there are no issues. This can be a significant improvement, as it allows systems to remain responsive and provides time to recover from transient problems.</p><p>However, deferring work does not eliminate failure. It postpones it.</p><p>If a consumer becomes unavailable, messages begin to accumulate in the queue. If the consumer is slow, lag steadily increases. If the consumer crashes repeatedly, retry behavior can amplify load and make recovery progressively harder. From the outside, the system may appear healthy for some time, but internally pressure is building.</p><p>This is the essence of the illusion of safety. Failure is no longer immediate, so it is easier to overlook, underestimate, or delay responding to.</p><p>To make this concrete, it is useful to look at the most common failure modes that appear in queue-based systems and how they are typically addressed.</p><p><strong>Failure mode: consumer availability and lag</strong></p><p>The most common failure mode is simple unavailability. When consumers are down or cannot keep up, the queue becomes a buffer that absorbs the mismatch between production and consumption rates.</p><p>Buffers are useful, but they are not infinite.</p><p>As lag grows, recovery time grows with it. A system that falls behind by minutes is very different from one that falls behind by hours. Designing for this failure mode means deciding up front how much lag is acceptable, how quickly consumers must be able to catch up, and when growing backlogs should trigger intervention.</p><p>That intervention is not limited to alerting. In many systems, it also includes automated scaling of the consumer fleet, temporary changes to concurrency, or dropping non-critical work. The important point is that lag is treated as a first-class signal, not an afterthought.</p><p>Retries also deserve careful attention. Unbounded or aggressive retries can turn a transient failure into a sustained overload during recovery. Backoff strategies, retry limits, and circuit-breaking behavior often matter more than raw throughput.</p><p><strong>Failure mode: infrastructure limits and scaling characteristics</strong></p><p>Queues introduce dependencies on infrastructure behavior, and that is an unavoidable part of using them. Retention limits, maximum queue size, throughput constraints, and scaling characteristics all shape how failure unfolds.</p><p>When these limits are reached unexpectedly, failure becomes abrupt rather than gradual. Messages may be dropped, producers may be throttled, or systems may stall entirely.</p><p>Designing for this failure mode means understanding the characteristics of the chosen infrastructure and treating them as architectural constraints rather than incidental details. Capacity planning, realistic load testing, and clear operational visibility are essential here. It is not enough to know that a queue can scale; it matters how quickly it scales and under what conditions.</p><p>The goal is not to eliminate these dependencies, but to ensure they are well understood and intentionally accounted for.</p><p><strong>Failure mode: concurrency, ordering, and duplication</strong></p><p>As systems scale, concurrency introduces another class of failure modes. Many queue-based systems rely on multiple consumers processing messages in parallel to increase throughput.</p><p>This has consequences.</p><p>Ordering guarantees may no longer hold. Messages may be delivered more than once. Related messages may be processed concurrently in ways that expose race conditions or inconsistent state.</p><p>These behaviors are not edge cases. They are normal in distributed systems.</p><p>Designing for this failure mode means assuming duplication will happen, making consumers idempotent, and being explicit about where ordering matters and where it does not. Competing consumers are a powerful pattern, but only when their implications are understood and reflected in the design.</p><p><strong>Designing for failure, not assuming safety</strong></p><p>Queues are powerful tools. They enable flexibility, decoupling, and resilience when used thoughtfully. But they do not make systems safe by default.</p><p>Resilient systems emerge when failure is anticipated, understood, and deliberately designed for. Queues can help create space to handle failure more gracefully, but they do not remove the responsibility to reason carefully about how the system behaves under stress.</p><p>Failure is still part of the system.<br> The difference is whether it is planned for or discovered the hard way.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ddb6a1113a37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is the Typical Microservices Architecture on AWS?]]></title>
            <link>https://medium.com/@techwithmatheus/what-is-the-typical-microservices-architecture-on-aws-f5220adbda16?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/f5220adbda16</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cloud-architecture]]></category>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 08:01:03 GMT</pubDate>
            <atom:updated>2026-01-28T08:01:03.821Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FgNLGDJT3fzoqQxjXJnoSA.png" /></figure><h3>What Is the Typical Microservices Architecture on AWS?</h3><p>When people ask what a “typical” microservices architecture on AWS looks like, they often expect something complex or highly specialised. In reality, most production systems converge on a surprisingly consistent shape.</p><p>That consistency comes from a small set of architectural pillars that, when applied well, make systems easier to scale, easier to reason about, and easier to evolve over time.</p><p>At a minimum, a microservices architecture needs:</p><ul><li>an entry point to expose services</li><li>compute to host them</li><li>data ownership to protect boundaries</li><li>communication so services can talk to each other</li></ul><p>So how do these pillars usually show up when teams implement microservices on AWS?</p><h3>Entry point</h3><p>Most systems use either API Gateway or an Application Load Balancer as their entry point.</p><p>API Gateway is typically chosen when teams want a managed API layer with built-in authentication, throttling, and request management. It works particularly well for API-centric workloads where those concerns would otherwise need to be implemented and maintained manually.</p><p>An Application Load Balancer, on the other hand, is a strong choice when routing HTTP traffic directly to backend services. It is simple, predictable, and cost effective at scale, which is why it appears so often in real-world architectures.</p><p>In more specialised scenarios, a Network Load Balancer may also be used. This usually applies when very low latency, static IPs, or non-HTTP protocols are required. It is less common for general microservices APIs, but it plays an important role when those constraints exist.</p><h3>Compute</h3><p>AWS does not force teams into a single compute model, and that flexibility is one of its strengths.</p><p>Lambda is commonly used for event-driven workloads or traffic patterns that spike unpredictably. In those cases, paying only for execution time rather than idle capacity can make a meaningful difference.</p><p>ECS and EKS are more commonly used for long-running services where teams want greater control over runtime behaviour, scaling characteristics, and deployment models. These platforms are well suited to services that are always on and need predictable performance.</p><p>In practice, many systems combine these approaches. The key decision is not choosing one compute option for everything, but selecting the right execution model for each service.</p><h3>Data ownership</h3><p>Data ownership is where architectural discipline really starts to matter.</p><p>Each microservice owns its data, which means there should be a separate database per service. This is less about the specific database technology and more about protecting service boundaries and avoiding tight coupling through shared schemas.</p><p>On AWS, DynamoDB is often chosen for its scalability and low operational overhead. RDS is commonly used when relational constraints, transactions, or existing data models are important. Both fit naturally into microservices architectures when ownership boundaries are respected.</p><h3>Communication</h3><p>Communication between services can take different shapes, and most production systems use more than one.</p><p>Asynchronous communication plays a major role in reducing coupling, smoothing traffic spikes, and improving overall system resilience. On AWS, this commonly means using queues or topics. Queues are useful when you need buffering and back pressure, while topics are useful when events need to be fanned out to multiple consumers.</p><p>Synchronous communication is also common, especially for request-response interactions between services. In these cases, services call each other directly over HTTP or gRPC. A service mesh can be used to manage this communication by handling concerns like retries, timeouts, traffic routing, and observability, without pushing that complexity into application code.</p><p>The important point is not choosing one style exclusively, but being deliberate about when to use asynchronous versus synchronous communication.</p><h3>Putting it together</h3><p>If you are getting started today, my rule of thumb is to keep it simple.</p><p>ALB plus ECS plus ECS Service Connect is a solid default. It is easy to reason about, scales well, and for many teams, it is exactly what they stick with long-term.</p><p>That combination is what most people are really referring to when they talk about a “typical” microservices architecture on AWS.</p><p>Understanding this baseline makes it much easier to evaluate more advanced patterns later on, without feeling overwhelmed by choice.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f5220adbda16" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Common Microservices Failure Modes (and Why They Keep Happening)]]></title>
            <link>https://medium.com/@techwithmatheus/common-microservices-failure-modes-and-why-they-keep-happening-15ce2cd7e3d0?source=rss-c154d483a24b------2</link>
            <guid isPermaLink="false">https://medium.com/p/15ce2cd7e3d0</guid>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <dc:creator><![CDATA[techwithmatheus]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 08:02:53 GMT</pubDate>
            <atom:updated>2026-01-22T10:45:26.728Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CmJ7kt0KCXPZyzZVovuSVQ.png" /></figure><p>Microservices are often blamed for being overly complex, slow, or fragile. When systems struggle, the conclusion is frequently that teams “went too far” or adopted microservices before they were ready.</p><p>In practice, that explanation rarely holds up.</p><p>Most failing microservices systems do not collapse because of scale or ambition. They fail because of a small number of design and organisational mistakes that look reasonable early on, but quietly compound as the system grows.</p><p>These are some of the most common failure modes I have seen repeat across teams, organisations, and industries.</p><p><strong>Overly synchronous service chains</strong></p><p>One of the earliest warning signs is a single user request triggering a long chain of synchronous service calls. Service A needs data from Service B, which in turn depends on Service C, and so on, just to return a response.</p><p>At first, this often feels like a clean separation of responsibilities. Each service does “one thing” and asks other services when it needs information. The problem is that this design creates fragile runtime dependencies.</p><p>Latency becomes unpredictable. A slowdown in one service ripples through the entire chain. Partial outages turn into full system incidents. Debugging becomes harder because failures are no longer local.</p><p>More importantly, this pattern is usually a symptom rather than the root cause.</p><p>When services constantly need to ask each other for data to do their job, it often means the boundaries were not drawn around real business capabilities. The decomposition made sense in diagrams, but did not survive contact with real workflows.</p><p>This is where techniques like event storming often reveal uncomfortable truths. The system is technically distributed, but conceptually tangled.</p><p><strong>Shared databases and blurred data ownership</strong></p><p>Shared databases are another classic failure mode, and one that often appears under the guise of pragmatism.</p><p>I have sat in architecture reviews where the concern was framed as “there are too many databases”. What usually followed was a proposal to consolidate data for simplicity or operational convenience.</p><p>The real issue, however, was not the number of databases. It was the absence of clear ownership.</p><p>Once multiple services can read and write the same data, independent deployment becomes risky. A schema change intended for one service can break another. Teams start coordinating changes. Releases slow down. Fear replaces confidence.</p><p>Over time, the system starts behaving like a monolith, except now the coupling is hidden behind network calls and shared tables. The architecture looks distributed, but the constraints feel familiar.</p><p>Patterns like Database per Service exist for a reason. They are not about purity. They are about protecting autonomy.</p><p><strong>Unclear ownership boundaries</strong></p><p>Ownership problems rarely show up immediately. They emerge slowly, often in systems that technically function but feel increasingly hard to evolve.</p><p>A service exists, but no team feels fully responsible for it. Bugs linger because ownership is unclear. Improvements are deferred because priorities are fuzzy. Architectural decisions drift because no one has the authority to say no.</p><p>This is where Domain-Driven Design offers insights that are often overlooked. The way teams collaborate matters as much as the way services communicate.</p><p>Partnerships, supplier and consumer relationships, and deliberate separation are not abstract concepts. They shape how responsibility flows through an organisation. When these relationships are undefined, services become shared problems rather than owned products.</p><p>Clear ownership is not a luxury. It is foundational.</p><p><strong>Treating microservices as a technology upgrade</strong></p><p>Finally, one of the biggest mistakes I see is treating microservices as something you “install” rather than something you adopt.</p><p>Teams migrate to microservices, but keep the same release processes, the same approval flows, and the same organisational structures. The architecture changes, but the way people work does not.</p><p>If you move to microservices, you need to deliberately reshape how teams operate. Release processes should allow teams to deploy independently without waiting on central gates. Approval flows need to stay close to the owning team rather than being spread across the organisation. Teams must be trusted to own their services end to end, from code to production.</p><p>Without these changes, microservices simply add complexity without unlocking autonomy.</p><p><strong>Alignment is the real architecture</strong></p><p>When microservices work well, it is not because of a specific framework or cloud service. It is because technical boundaries, team boundaries, and ownership models reinforce each other.</p><p>That alignment is what makes systems easier to reason about, easier to evolve, and more resilient over time.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=15ce2cd7e3d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>