DEV Community: Max Rohde

What's the Best Model to use with OpenCode

Max Rohde — Thu, 12 Mar 2026 00:29:27 +0000

I have been extensively using OpenCode over the past few months.

Overall, it has been working very well for me – but one issue I struggled with is to determine what model to use.

There are hundreds to choose from, and, interestingly, what seems to be straightforward choices often do not work.

I especially struggled with getting Gemini to work. It produces very subpar code and would often get stuck.

Models are evolving quickly, so it's not very useful for me to give you a specific model to use. Instead, I thought it's best I share the strategies I use to determine which model to use.

I'll give them in the order I find most effective to least effective:

(1) OpenRouter Statistics

A good indication if a model 'works well' for OpenCode is what other user's are using!

OpenRouter keeps statistics on what models are used for various app, so that feels like an obvious starting point.

For whatever reason, OpenCode is filtered out in many views in OpenRouter. However, OpenRouter still keeps statistics for OpenCode, they can be found here:

https://openrouter.ai/apps?url=https%3A%2F%2Fopencode.ai%2F

This is the snapshot as of today:

It seems like users are having success with the Anthropic models as well as some open source models, like Kimi K2.5 and MiniMax2.5.

Here it is good to keep in mind that OpenCode makes certain models available for free – as of writing this, Kimi K.24 for instance, is free to use.

(2) OpenCode Go Models

OpenCode has an offering called OpenCode Go, that's a fixed price per-month subscription that includes usage of a certain set of models.

Chances are, models included here will work well with OpenCode.

As of writing this, the following models are included:

GLM-5
Kimi K2.5
MiniMax M2.5

(3) OpenCode Documentation

OpenCode includes a number of model recommendation in their documentation:

I'm putting this one last, since it included Gemini 3 Pro – which I never got to work correctly.

(4) Experiment!

In any case, OpenCode makes it easy to switch between models. So when using an aggregator service like OpenRouter or OpenCode Zen, it makes sense to quickly try out different models.

Just be mindful that some providers will use your data for training – so always best to check the model first before giving it a try.

How to Avoid Route 53 $0.50 / Month Charge per Hosting Zone using Free CloudFront Distribution

Max Rohde — Wed, 03 Dec 2025 01:42:11 +0000

AWS Route 53 charges US$0.50 per hosted zone per month.

Even when we otherwise use AWS services sparingly - Route 53 charges a fixed amount

This can quickly add up if you have multiple domains – especially when using different AWS accounts for dev, uat and prod; which each will need their own hosted zone.

Thankfully AWS has recently release flat-rate pricing for CloudFront distributions, and one of the included services for the free-tier plan is a Route 53 hosted zone 🥳

Using CloudFront distributions, you can reduce our costs for hosted zones to $0.00.

Much better when we can replace the $0.50 from Route 53 with our free CloudFront plan

And, best of all, you don't need to change our application for this!

You don't need to update your existing CloudFront distributions – you can simply create a new one and point it to any subdomain in the hosted zone.

Here is how to do it:

Head to the AWS Console and Open CloudFront / Distributions
Click [Create Distribution]
Select the Free plan and click [Next]

Choose any name and description you like
IMPORTANT: For Domain, provide a subdomain of the hosted zone domain in Route 53 you would like to offset the costs for.
- For instance, if your domain is mydomain.com - you can choose offset.mydomain.com
When you did everything right, you will see the following confirmation:

For specify origin, choose Other
Provide any domain / path you like. E.g. point back to your main domain.
Enable rate limiting on the security page and go [Next]
Create a new TLS certificate
- IMPORTANT: if you have the choice to use an already existing one, I would recommend to not choose it and instead create a new one. This way, we are not interfering with any other setup made in the account.
Now you can create the distribution.
Once the distribution is created, click [Manage plan] under billing.

Look for the line 'Route 53 DNS: [your hosted zone domain]' - if that is there, you won't be charged the US$0.50 per month anymore for this hosted zone 🥳

That's all we need to do. If you are already using CloudFront, you could of course also change any existing CloudFront distribution to use the flat-rate pricing.

But good luck with that! You will likely find it is not possible out of the box – due to many features in CloudFront not being covered in the flat-rate pricing.

And if you use any of these features, the option to select the free plan will be grayed out:

Much easier to create a new distribution under a different sub-domain!

If you are considering deploying a Next.js based project using CloudFront, please consider my free starter templates:

I haven't updated them to use the flat-rate CloudFront distribution but will likely do so in the future - please raise an issue if you are interested in this feature and this will surely motivate me to get to it quicker.

When your Next.js Site Reports: Title tag Missing

Max Rohde — Tue, 02 Dec 2025 07:19:05 +0000

I got an unexpected message from the Ahrefs website monitoring for one of my pages deployed using the Next.js + Tailwind template:

Title tag missing or empty: 4 URLs

I remember fixing all the tags a while ago, so I was quite puzzled.

In dev, everything looked fine, and it took me a while to uncover what was going on.

So I thought I share what I found here in case it helps someone facing the same issue.

What happened in my case is that I added a variable to the title tag declaration in the next/head component:

Previously:

<title>Frequently Asked Questions</title>

Now:

<title>Frequently Asked Questions - {appConfig.brand.title}</title>

This for some reasons resulted in Next.js, when doing a static export (output: 'export'), leaving the title blank.

The easiest way to see this is to go to your affected site and use the 'Show page source' option of your web browser.

Thankfully, there is an easy fix.

Fix by using template literals:

<title>{`Frequently Asked Questions - ${appConfig.brand.title}`}</title>

With this fix, the title tag for my site again contained the correct value.

Not sure why this is how it is – but I'm sure there is a good reason 🤔

And hoped this saved you some time!

If so, why not stop by my totally free Starter Project Builder Goldstack and consider it for your next project using Next.js 🤗

Notion MCP vs Notion MCP Server

Max Rohde — Sat, 23 Aug 2025 06:22:32 +0000

The Model Context Protocol or MCP for short is the de facto standard for using external services in your AI chat sessions.

Thankfully, Notion offers ready-made MCP solutions.

However, there are two different offerings, which can become a bit confusing:

Notion MCP: Tools hosted by Notion
Notion MCP Server: Official Notion repository with MCP server

Notion added a note to the Notion MCP repository directing users to the Notion MCP server hosted by them.

Usually, using a hosted version of a service is always the best idea - since that usually helps us to get going quickly and reduce maintenance headaches in the long run.

Unfortunately, I found the Notion MCP service fundamentally lacking.

Thus I would recommend you to put in the extra effort to use the open source server.

My reasons:

Lacking search function in Notion MCP

Notion MCP supports a 'search' tool, which allows to perform a full text search across your whole workspace.

This can be useful at times, but I find AI the most useful when you give it razor-sharp instructions.

In the context of Notion, this would mean a specific page, or a specific set of sub pages for a database.

For instance, I had a few entries in a database that were missing a title. The instructions to my agent where:

Create a short title for all entries missing a title for the database https://www.notion.so/xxx

The Notion MCP server is not able to do this, since it doesn't have the capability to 'get all pages of a database' or 'get all pages for a database that match a specific filter.'.

Technically, you can provide a database ID as context, but since you are forced to provide a query text, it is not possible to retrieve all pages for a database using the search tool.

You would receive errors such as:

Error executing MCP tool:
MCP error -32602: MCP error -32602: Invalid arguments for tool search: [
  {
    "code": "invalid_type",
    "expected": "string",
    "received": "undefined",
    "path": [
      "query"
    ],
    "message": "Required"
  }
]

Error executing MCP tool:
MCP error -32602: MCP error -32602: Invalid arguments for tool search: [
  {
    "code": "too_small",
    "minimum": 1,
    "type": "string",
    "inclusive": true,
    "exact": false,
    "message": "String must contain at least 1 character(s)",
    "path": [
      "query"
    ]
  }
]

The Notion MCP server, in contrast, handles this tasks without any problems.

Only Small Subset of Notion Features Available on Notion MCP

Further to the above only supports a fraction of the Notion functionality.

See the complete list here.

Notion MCP – Supported tools

Whereas the API easily covers twice as much of Notions' functionality:

Notion API Reference

Open Source Notion MCP Server Easy to Setup

Using the setup instructions on the Notion MCP Server GitHub page, it only took me around two minutes to have the Notion MCP server up and running in my environment (Cline extension for VSCode).

Setup instructions for Notion MCP server

It actually took me longer to get the Notion MCP service running due to some confusion on my part about the server type.

Some Instability on Notion MCP

Looking at the GitHub issues for Notion MCP Server, a lot of users seem to use that forum to make known their issues with the Notion MCP server:

why has MCP not been fixed yet? It has been an ongoing issue for 3 weeks now!

401 using mcp.notion.com/mcp

MCP error -32000: Connection closed

Conclusion

I think combining Notion with your favorite LLM chat tool is an extremely powerful proposition.

I strongly recommend considering using the open source Notion MCP server for now (even though it may use more token).

I hope that Notion will improve their hosted MCP server and will be very happy to update this article when this happens.

Pinecone Price Increase 😱 Is Chroma Cloud the Best Alternative?

Max Rohde — Sat, 09 Aug 2025 03:02:30 +0000

I have been a happy user of the Vector database Pinecone, which provided me with a truly 'serverless' experience.

I only needed to sign up, get an API key, and then pay for the usage of my applications.

Unfortunately, Pinecone decided to change their pricing model as announced in their email 'Important pricing update: minimum usage fee' 🤯

From 1st of September, all users - regardless of how extensive your actual use is - need to pay a minimum of US$ 50 per month.

Not ideal for me, since I generally managed to keep my bills under US$10 - by storing only the most essential data in the Vector DB (embeddings only and not the document content).

Needless to say, I was not very pleased and decided to migrate away from Pinecone for the main application I use a Vector DB for: AI Auto Relation for Notion.

As I assumed, I wasn't the only one facing this issue and quickly found the helpful Reddit thread: Pinecone’s new $50/mo minimum just nuked my hobby project - what are my best self-hosted alternatives?

I think the best alternatives from this conversation with everyone with less than US$50 per month of Pinecone costs are:

Self hosted Postgres with pgvector
Self hosted Chroma
Fly.io 'managed' Postgres (with pgvector)
Chroma Cloud

I was looking for a truly serverless solution; where I don't have the overhead of managing another server and my costs scale up linearly based on my usage - starting at $0.

As far as I could establish in my research Chroma Cloud is the only solution that provides this.

So I went ahead and changed the vector database for my Notion integration to Chroma Cloud.

Here everything I found out that could be of help for anyone interested in doing the same:

I wasn't too impressed by the documentation. It all seemed a bit 'alpha' to me. However, there is of course the documentation of the Chroma open source project to complement this - but this I found to be not that great either. For example, I was looking for some information about the error codes the TypeScript SDK would return - so I could handle these - but wasn't able to find any information about this.
The management interface seems to be more simplistic in comparison to Pinecone. However, it is able to help with the basics - e.g. see items in collection, do some basic searching and see some statistics.

I understand Chroma does not scale as well as Pinecone. Thus, it could be advisable to split one 'Index' in Pinecone into multiple Chroma 'Collections'. I realised this only too late in my implementation. So I will hold my breath as to how well Chroma will perform for my solution (which only deals with a few thousand documents).

I just finished testing the new implementation today. As I learn more, I will update this post.

Otherwise, would be interested if anyone has found a better alternative.

Migrating Maven Namespace to Central Portal

Max Rohde — Thu, 08 May 2025 22:28:09 +0000

If you publish your Java artifacts to Maven Central, you may receive an email with the following content:

Greetings OSSRH Publisher,

As you may have heard, OSSRH is reaching end of life on June 30, 2025. OSSRH users need to migrate their namespaces to the Central Portal as soon as possible.

Instructions for self migration are located here: https://central.sonatype.org/faq/what-is-different-between-central-portal-and-legacy-ossrh/#self-service-migration

To make the transition smoother we will be automatically migrating publishers that have not used oss.sonatype.org or s01.sonatype.org to publish artifacts in some time starting with the oldest and working our way forward. To avoid disruption to your publishing processes we strongly encourage migrating before the June 30, 2025 deadline.

Thank you for your assistance,

The Central Team

This requires us to do a few things!

Migrate Namespace to Central Portal
Updating Maven Plugin
Updating GitHub Action

Migrate Namespace to Central Portal

This assumes your namespace has not been automatically migrated yet. If it has, just skip to the next section!

Go to the Namespaces page and click [Migrate Namespace] and then [Migrate]

You should see the following configuration:

And it will look as follows after the migration has been completed

Updating Maven Plugin

We need to also update the plugin to publish to Maven Central
Look for a configuration as follows in your pom.xml:

    <plugin>
                <groupId>org.sonatype.plugins</groupId>
                <artifactId>nexus-staging-maven-plugin</artifactId>
                <version>1.6.13</version>
                <extensions>true</extensions>
                <configuration>
                    <serverId>ossrh</serverId>
                    <nexusUrl>https://oss.sonatype.org/</nexusUrl>
                    <autoReleaseAfterClose>true</autoReleaseAfterClose>
                </configuration>
    </plugin>

And replace it with the new central-publishing-maven-plugin as per instructions from https://central.sonatype.org/publish/publish-portal-maven/

<build>
    <plugins>
        <plugin>
          <groupId>org.sonatype.central</groupId>
          <artifactId>central-publishing-maven-plugin</artifactId>
          <version>0.7.0</version>
          <extensions>true</extensions>
          <configuration>
            <publishingServerId>central</publishingServerId>
            <autoPublish>true</autoPublish>
            <waitUntil>published</waitUntil>
          </configuration>
        </plugin>
    </plugins>
</build>

Note we set the following to ensure this works in CI

<autoPublish>true</autoPublish>

And we also set to ensure our build fails if there is anything wrong. This will make the build take longer but we can ensure the package is actually published before the build completes!

<waitUntil>published</waitUntil>

Updating GitHub Action

We also need to update our GitHub actions configuration if we publish using it.
Go to https://central.sonatype.com/account
Click [Generate User Token]

Click [Ok]

You should get a username and a password
We need to store them as GitHub secrets. For this go to the Settings of your repository and add them as new repository secrets:

Create the repository secrets MAVEN_USERNAME and MAVEN_PASSWORD
It should look as follows:

We use the setup-java action to ensure settings.xml is created correctly:

name: Publish package to the Maven Central Repository
on:
  release:
   types: [created]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - id: install-secret-key
        name: Install gpg secret key
        run: |
          cat <(echo -e "${{ secrets.OSSRH_GPG_SECRET_KEY }}") | gpg --batch --import
          gpg --list-secret-keys --keyid-format LONG
      - name: Set up Maven Central Repository
        uses: actions/setup-java@v2
        with:
          java-version: '20'
          distribution: 'adopt'
          server-id: central
          server-username: MAVEN_USERNAME
          server-password: MAVEN_PASSWORD
      - name: Publish package
        run: mvn --batch-mode -Dgpg.passphrase= deploy -DskipTests
        env:
          MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }}
          MAVEN_PASSWORD: ${{ secrets.MAVEN_SECRET }}

Now we should be able to run the GitHub action. Console output should look similar to:

[INFO] --- central-publishing:0.7.0:publish (injected-central-publishing) @ delight-nashorn-sandbox ---
[INFO] Using Central baseUrl: https://central.sonatype.com
[INFO] Using credentials from server id central in settings.xml
[INFO] Using Usertoken auth, with namecode: ***
[INFO] Staging 7 files
[INFO] Staging /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/delight-nashorn-sandbox-0.5.2.jar
[INFO] Installing /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/delight-nashorn-sandbox-0.5.2.jar to /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-staging/org/javadelight/delight-nashorn-sandbox/0.5.2/delight-nashorn-sandbox-0.5.2.jar
...
[INFO] Pre Bundling - deleted /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-staging/org/javadelight/delight-nashorn-sandbox/maven-metadata-central-staging.xml
[INFO] Generate checksums for dir: org/javadelight/delight-nashorn-sandbox/0.5.2
[INFO] Going to create /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-publishing/central-bundle.zip by bundling content at /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-staging
[INFO] Created bundle successfully /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-staging/central-bundle.zip
[INFO] Going to upload /home/runner/work/delight-nashorn-sandbox/delight-nashorn-sandbox/target/central-publishing/central-bundle.zip
[INFO] Uploaded bundle successfully, deployment name: Deployment, deploymentId: xxx-0c5d-4912-b802-392b1377670c. Deployment will publish automatically
[INFO] Waiting until Deployment xxx-0c5d-4912-b802-392b1377670c is published
[INFO] Deployment xxx-0c5d-4912-b802-392b1377670c was successfully published

You can also check the status of your deployment by going to https://central.sonatype.com/publishing/deployments

Voice Memos with ChatGPT: My First "GPT"

Max Rohde — Sat, 06 Apr 2024 02:20:13 +0000

I've always been fascinated by how Large Language Models (LLMs) can make our interactions with technology feel more natural. These models are not just about turning speech into text. They're skilled at understanding what we mean, even when how we say it isn't clearly expressed. LLMs are great at finding the important points in our messy spoken words.

My interest grew when ChatGPT introduced a voice conversation feature. However, I quickly realised that talking to ChatGPT could be awkward. ChatGPT is optimised for producing text we read rather than text we listen to. We read faster than we listen. So, long answers from ChatGPT felt slow because it took so long for it to read them out in their entirety.

Thinking about this, I wanted to explore a way to use the voice conversation feature in a new and helpful way: note taking.

My idea was to use ChatGPT to record voice memos. This uses the transcription abilities of ChatGPT in a useful way. For this, I developed a custom "GPT" to make recording voice memos as smooth and effective as possible.

Check out the GPT here: Voice Memo

In the remainder of this article, I explain how this GPT works and provide my impressions of working with GPTs in generatl.

What are GPTs or Custom GPTs?

Custom GPTs are versions of ChatGPT that you can customize for specific tasks or areas of interest. This doesn't require any coding, making it accessible to everyone interested in AI.

For those who know how to code, there's more you can do. You can add code to connect these GPTs to outside data or services. This means GPTs can do almost anything. They can increase productivity, help with learning, or provide new entertainment options.

But, there's a catch. To create or use custom GPTs, you need a ChatGPT Plus subscription. This costs US$20 a month. Both creators and users of custom GPTs need this subscription to access them.

The Voice Memo GPT

I want to explore a new way to use ChatGPT; to use it to quickly capture thoughts, similar to many voice memo apps available on the app stores.

Imagine talking to ChatGPT and expressing your ideas. Then, instead of giving you a long response as it would usually do, it simply says "noted." That's the main idea.

With a special prompt I'll share below, ChatGPT acts as a recorder for your thoughts. It creates a transcript you can later reference or share with other applications such as Notion.

Here's how it works:

create a new conversation with the Voice Memo GPT
hit the headphones button near the chat box, and speak.

ChatGPT will capture your words and confirm with short responses. This way, you get a transcript of your thoughts without AI adding its own twist.

The GPT not only records thoughts but also answers questions when explicitly asked. So, if you're brainstorming and have a query, ChatGPT will respond with its suggestions. Otherwise, it'll just document your thoughts.

I think this could be quite useful for note-taking and brainstorming.

Below is the prompt to make ChatGPT your personal voice memo tool. You can create your own GPT for it or simply start your conversation with it when using the free version of ChatGPT.


You just listen to ideas presented by the user.

- If given a specific question from the user, answer as succinctly as possible.
- If the users input ends on an uncompleted sentence, prompt 'And?'
- Otherwise, respond with 'Noted.'
- If you are running on the web version and not the mobile version of GPT. Your first reply should include. 'Note that voice conversations are only supported on mobile devices.'

DO NOT SUMMARIZE, DO NOT COMMENT, unless specifically prompted to do so.

You are allowed to answer a user's query on your prompt above. If the user asks you how you function, respond with the information from the prompt.

Conclusion

Creating a custom GPT is incredibly easy. It can be done in just a few minutes. But for more complex uses, the challenges quickly added up.

Making conversations with GPT smooth was harder than expected. The system would often interrupt me mid-sentence, which broke the flow of my thoughts. Especially with voice memos, these interruptions felt awkward and made the experience less enjoyable.

Despite these issues, I think there is a lot of potential in using ChatGPT to capture and refine our thoughts, as opposed to the usual usecase of answering questions. I'm looking forward to any feedback on anyone who is happy to try out the GPT or the prompt.

I've shared the full prompt for this project for those interested in experimenting or creating something new.

Death by Cloud or How to Build Brittle Systems

Max Rohde — Fri, 01 Mar 2024 20:46:41 +0000

The allure of serverless computing and cloud-based solutions was once irresistible to me. The promise of speedier system development and simpler maintenance seemed like a dream come true. I eagerly advocated for these technologies, writing numerous articles on the subject. Yet, as time passed, my enthusiasm waned as I came across a number of challenges which lead me to believe that cloud computing and serverless architectures are not the cure all they were touted to be.

In this article, I will first summarise some learnings we have gained over the past years of using Serverless and then discuss the surprisingly fleeting nature of serverless solutions using an example. Lastly, I propose a number of considerations for building more sustainable systems.

Some Learnings from a Decade of Serverless

Serverless has been extensively discussed in the past years. Here some of the key learnings:

Infrastructure Complexity: Serverless computing emerged as a simplified approach to application development, but the infrastructure it requires can be unexpectedly complex. Tasks like setting up an API gateway with Lambdas can result in extensive configuration, increasing brittleness and the learning curve for developers.
Costs: Cost-wise, serverless is often marketed as economical but can lead to higher expenses due to unpredictable pricing models. These costs can outweigh savings from reduced physical hardware needs.
Backwards Compatibility: Service evolution poses another challenge; cloud providers frequently deprecate services or versions, forcing developers to rewrite applications for compatibility. This disrupts operations and shifts focus from innovation to maintenance.
SDK Dependency Hell: Integration with cloud services has also become more complicated. The vast number of features leads to bloated SDKs and 'dependency hell', where managing libraries and their security updates consumes significant time and resources.
Enhanced Security: Despite these hurdles, serverless computing does offer enhanced security through better isolation between components. This architecture limits the impact of breaches, allowing for more secure, compartmentalised service management.

In summary, while serverless technology provides certain advantages such as improved security, it also introduces complexities in infrastructure setup, cost management, service compatibility, integration processes, and dependency maintenance that organizations must navigate carefully.

The Fleeting Nature of Cloud-Based Systems: An Example

Among the various concerns discussed, one stands out as particularly troubling to me: the transient nature of cloud-based systems. These systems are not built to endure; they are fleeting. This impermanence is concerning because it contradicts one of the purported benefits of serverless computing—that it requires less maintenance due to the service provider managing many infrastructure layers. While this is still somewhat true, other factors have emerged that complicate ongoing operations.

Consider a broad comparison between a modern cloud-based solution and embedded software running on a manufacturing machine. Some machines operate on software that is decades old and is still functional. In contrast, a serverless system seems to demand significant overhauls every few years just to remain operational.

Let me illustrate this with an example from my personal experience, for my project Goldstack. Last year, around December, I received a notification from AWS informing me that I could no longer update my Lambda functions because they were implemented using Node 16—a runtime AWS was phasing out (also due to Node 16 end of life). Initially, updating my application's code and build logic to Node 18 seemed straightforward—it involved modifying several Lambdas and ironing out some code incompatibilities over a few days.

## [Action Required] AWS Lambda end of support for Node.js 16

However, I soon discovered that the new Node 18 Lambda runtime no longer included the AWS SDK by default—a sensible decision perhaps, but one with significant implications for my project. The deployment size of my Lambdas quadrupled from around one megabyte to four megabytes because I had designed my solution assuming access to the provided AWS SDK in the runtime environment.

To address this issue, I had to upgrade to v3 of the AWS SDK—a move aimed at reducing Lambda sizes but one which also led to increased cold start times. This upgrade was far from trivial; it necessitated rewriting every piece of code interacting with AWS services in some way due to the different programming model introduced by the SDK v3. The effort spanned weeks—time carved out from weekends here and there—resulting in a solution with identical functionality as before but now compatible with AWS's new requirements.

This experience underscores how serverless cloud-based systems can become burdensome rather than liberating for developers. The need for constant updates simply to keep systems operational raises questions about sustainability and long-term viability in an environment where change is relentless and often forced upon us by service providers' decisions.

The Quest for Sustainable Systems

It's always easier to highlight flaws than to craft solutions, particularly in our complex tech industry. I must admit that I don't have a silver bullet to offer as an alternative to cloud computing and serverless architectures. We've experienced the limitations of monolithic systems, and they too fell short of our expectations. It seems neither serverless nor on premise monolith is the definitive answer; hopefully the solution we seek is still out there, waiting to be discovered.

In our pursuit of more sustainable systems, it's crucial to challenge ourselves to keep this questions in mind: how do we build technology that endures? One interesting observation comes from looking at the lifespan of companies and technologies. Counterintuitively, it's often the older, seemingly outdated technologies that stick around the longest. For example, mainframe computers, first introduced in the 1950s, are still in use today, running critical processes for banks and airlines.

This phenomenon suggests that chasing after the latest trends may not be our best strategy if we aim for longevity. The newest tech on the block might be more prone to becoming obsolete quickly compared to its older counterparts that have stood the test of time.

As an industry fixated on innovation, we often rush towards using services in their alpha or beta stages—enticed by cloud providers' promises of cutting-edge capabilities. However, this eagerness can lead us down a path where our creations are transient by nature—destined for obsolescence before they've had a chance to mature.

The solution remains elusive but acknowledging these patterns is a step towards finding it. We need to balance innovation with sustainability and consider how new technologies will fit into long-term strategies. While we may not have all the answers now, I remain hopeful that as an industry, we will eventually find a way to build systems that are not only useful but also built to last.

Mock S3 for AWS SDK for JavaScript (v3)

Max Rohde — Fri, 19 Jan 2024 20:16:30 +0000

It has been a few years now since AWS upgraded their official JavaScript SDK to version 3. This new version is not backwards compatible with v2 of the SDK. So any code relying on the AWS SDK would have to be changed quite extensively.

This is why I had been procrastinating to update the SDK version for my Goldstack Starter Project Builder. However, AWS's recent end of support for Node.js v16 Lambda runtimes has forced my hand. Since Node.js v18+ runtimes no longer include the v2 aws-sdk package and this, in turn, has significantly increased the size of the Lambda's I have to deploy (from ~1 MB to almost 6 MB).

I love writing meaningful end-to-end test scenarios in unit tests and ideally limit the use of hand-crafted mocks as much as possible. For instance, I prefer to use in memory databases in tests over mocking individual function calls for database operations.

I did the same for S3 when implementing Goldstack by using a local mock S3 service. Specifically, I used the npm package mock-aws-s3. This package provides an S3 instance that stores objects in local files.

Thus, when passing in an instance of S3 created with mock-aws-s3, complex local tests could be performed, including the writing and reading of objects, who would be persisted for the duration of the test. The same package could also be used for running a local development environment.

I have packaged all this up in my S3 Template.

Unfortunately, the mock-aws-s3 package only supports the AWS SDK v2. Thus, in order to upgrade to v3 of the SDK, I needed an alternative S3 mock, but could not find any that supports in-memory or file-based persistence.

In response, I developed a thin wrapper around the mock-aws-s3 package that exposes the AWS SDK v3 using aws-sdk-mock:

mock-aws-s3-v3: Package to provide a file-based mock for AWS S3 for local testing.

This mock can easily be used in unit tests and for local servers:

import { createS3Client } from 'mock-aws-s3-v3';
import { GetObjectCommand } from '@aws-sdk/client-s3';

const client = createS3Client('./local-folder'); // of type S3Client

await client.send(new PutObjectCommand({
  Bucket: 'test-bucket',
  Key: 'test-key',
  Body: 'hello',
});

This will create the folder ./local-folder/test-bucket and place a test-key file within it. The contents of the file can then be easily retrieved using a GetObjectCommand:

const res = await client.send(new GetObjectCommand({
  Bucket: 'test-bucket',
  Key: 'test-key',
}));

The supported operations are the same as mock-aws-s3 minus getSignedUrl - which is not part of the S3 client package anymore in V3 of the SDK. Here a list of supported operations:

CreateBucketCommand
DeleteBucketCommand
ListObjectsCommand
ListObjectsV2Command
DeleteObjectsCommand
DeleteObjectCommand
GetObjectCommand
HeadObjectCommand
PutObjectCommand
CopyObjectCommand
GetObjectTaggingCommand
PutObjectTaggingCommand

This package is used for dozens of tests in the Goldstack monorepo but I would still consider it an early alpha version. If you encounter any issues, please check out the source code, and be welcome to open an issue if there is anything you require help with.

Upgrading to Yarn 4

Max Rohde — Sat, 30 Dec 2023 00:31:07 +0000

I maintain a set of templates and a starter project builder for fullstack projects: Goldstack. This project makes heavy use of Yarn 3 features, specifically for workspace management.

I realised that a new version of Yarn, Yarn 4 was released recently, so I wanted to explore if I can easily update this project from Yarn 3 to Yarn 4.

This project contains more than 70 workspaces (including sub-workspaces) and uses a number of frameworks and libraries, such as:

TypeScript
React
AWS SDK
Next.js
ESLint
and many more

So I think it can be a good testing ground for upgrading to Yarn 4.

I completed the upgrade and released this in version 0.5.0 of Goldstack.

Overall it took me around 3 hours to perform the upgrade. Here an overview of what I needed to do:

Updating Yarn

First, Yarn needed to be updated to version 4 using the following commands:

yarn set version stable
yarn install

Note that this may upgrade to a later version than Yarn 4 if you run this at a future point in time.

Upgrading Node version

Yarn 4 is not compatible with earlier versions of Node. Specifically Node 16 is no longer supported.

I needed to ensure that all GitHub actions provide an environment that runs in Node 18:

    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: '18'

Fixing CLI commands

There was an incompatible change included in Yarn 4 with respect to the foreach command. Previously it was possible to run a command as follows:

yarn foreach run clean

However, now Yarn requires to add a qualifier. Specifically one of the following:

Command	Description
`-A,--all`	Run the command on all workspaces of a project
`-R,--recursive`	Run the command on the current workspace and all of its recursive dependencies
`-W,--worktree`	Run the command on all workspaces of the current worktree

I provided the -W or --worktree option for all occurrences where I previously used foreach. I usually just wanted to run a command for all packages for a workspace - but not including recursive dependencies or all packages in the whole project (what -A will do).

A worktree is defined in the Yarn documentation as:

[...] a worktree is the name given to workspaces that list their own child workspaces.

I would say overall it was a fairly easy process to upgrade to Yarn 4. Next from here I would like to explore:

Yarn now supports having its binary managed through corepack. My template currently still uses yarnPath.
Yarn supports a hybrid mode that allows managing package dependencies using Yarn Plug'n'play and the 'node linker' (that requires the node_modules) folder alongside each other. I want to explore whether this can be used to create a mobile template based on Expo

Why You Should Become and Engineering Leader (or Not)

Max Rohde — Sat, 28 Oct 2023 22:01:45 +0000

As a software engineer, you're likely content with your role. Coding can be both enjoyable and rewarding. However, many engineers ascend to leadership roles only to discover that it's not for them and end up in a career dead end.

Often, the better you are at coding, the more you love it, the more likely it is that you won't enjoy being a leader.

Being a good and effective leader, especially in this day and age, is incredibly difficult. Thus I recommend that you carefully weigh your reasons why you want to become a leader.

Don't become a leader for the wrong reasons, or you set yourself up for unnecessary strive and unhappiness.

In the following, I list some 'doubtful' reasons that should make us pause before continuing with aspiring to become a leader, and 'wholesome' reasons that indicate we could be on a more fruitful path.

Everyone is different, and everyone values different things. So don't take my categorisation of reasons as absolute. Reasons listed as 'doubtful' here may work perfectly for you and if that's the case, don't let me stop you!

Doubtful Reasons

💪 I Want Power

One of the most alluring qualities of become a leader is that we assume we will get more power. Power is something we naturally strive for, even though we are not as close to lobsters as some people think we are.

But don't be fooled. A good leader will get to enjoy very little power. As a leader, your job will not be to tell people what to do and what not to do. Instead your job is to gently influence those you lead so that their work is organised in a way that is to their and the organisation's benefit.

You do your job best not when you are bossing around everyone all day or be the recognised mastermind behind a team's success. You do it best when your contributions are barely recognisable.

💰 I Want more Money

It is true that salary in leadership positions is often higher than that for individual contributor positions. However, this is changing in our industry. Individual contributors, also known as ICs, are now able to hold more senior, and better renumerated, positions.

In any case, is it worth to exchange a job that you like for one that you hate for an increase in salary? As long as you don't need the extra money for your or your loved ones' survival, I suggest to put this last in your considerations of whether to become a leader.

👩‍💻 I Want to Ensure We Don't Write Bad Code

If you love coding and care about coding, you would have encountered situations in which you disagree with the technical direction of the team: things are not 'done right'.

A leadership position may seem tempting because it would give you the ability to shape the technical directions and standards better. This is true to some degree. However, there are plenty of other things you have to worry about as a leader.

You will probably end up being more disconnected from the code than when you were working as an individual contributor in the team. Being a leader is not about micro-managing what your team does and policing their every line of code.

Wholesome Reasons

💬 Someone Told Me I Could be a Good Leader

If your manager or others let you know that they think you could be a good leader, it is usually a good indication that you could be.

The best leaders are chosen by the people they lead.

If you find yourself to be elected for leadership tasks such as planning a project, organising something for the team, or being in charge of technical decisions, this is also a good indication that leadership could be a good avenue for you to pursue.

🌱 I Want to Help People Grow

If you listen carefully to leaders, you will hear them complain a lot about their work. That is fair enough; leadership is hard.

However, if you ask leaders what they find most rewarding in their jobs, it is often that they were able to help others grow or help them overcome their problems.

If growing and helping others is a key value of yours, the most enjoyable parts of leadership will be even more enjoyable for you.

🍸 I Want to be Lazy

Laziness is generally not a sure path to success, but there is a certain flavour of laziness that is an trait of successful engineers.

Take testing for instance; engineers are too lazy to do the same tests over and over again, thus they create test automation.

This laziness is one of the traits that can make you both a good engineer and a good leader; since a good leader needs to delegate - which is a very sophisticated variation of automation.

But don't get your hopes up; just as an engineer's dream of reaching their nirvana of automation-enabled idleness is never realised, a leader's work never runs out and will keep you busy.

🌟 I Want to Make an Impact

If you care about making an impact in the world, you will be able to make a bigger impact if you become a leader.

Our world is shaped by people, and we can change the world by influencing people. Influencing people to achieve particular outcomes lies at the heart of leadership.

Being a leader is difficult but you can make a difference by being a leader. The technology industry lacks good leaders and poor quality leadership is an often cited reason engineers do not enjoy their jobs. You can do your part to change that.

Making Your Decision

Think carefully about why you want to become a leader. Leadership isn't easy; having robust motivations for taking on this challenge will be key to your success.

Your motivations and values will determine whether you'll make a good leader. Don't become a leader if you are just seeking power. You won't be a good leader for your people, and it will be difficult for you to be successful and happy.

However, everyone is different and you may have your unique reasons that work for you. Key is not whether the reasons listed here apply to you or don't. Key is that you spend some time thinking of what motivates you and if it will align with what will be required of you as a leader.

Control Windows with Your Voice and the Magic of ChatGPT

Max Rohde — Fri, 29 Sep 2023 00:35:16 +0000

Typing is the most common way we interact with our computers, but we can talk much faster. Even with practised fingers, we barely type 40 words per minute, yet we effortlessly speak at around 150 words per minute - triple the speed.

However, using our voice to instruct our computers had two major hurdles. Firstly, computers used to be quite awful at transcribing our voices into text. Take Dragon NaturalSpeaking 2006, for instance. It merely decoded our speech with roughly 80% accuracy. I personally found it more time-consuming correcting these minor errors than simply typing the content.

Secondly, the precision required by computers clashed with our naturally imprecise spoken language.

Fortunately, these issues have somewhat disappeared as of late last year, thanks to technological advances. The remarkable OpenAI Whisper model excels at voice-to-text transcription - it even has a grip on my German accent! Meanwhile, OpenAI's GPT-4 model manages to comprehend our natural language usage, translating it into computer-understandable format. It has shown its merit, for instance, through its remarkable code-writing capability.

With these innovations - OpenAI Whisper and GPT - I wondered if I now can control my computer - specifically my personal Windows computer with my voice.

In the rest of this article, I'll explain how I combined the OpenAI API, AutoHotKey and a simple Go program, to control Windows with my voice.

The read-to-use tool and all source code are on GitHub.

tldr;

If you want to see what I developed in action, please just have a look at the YouTube video below.

My tool offers the versatility to trigger numerous actions including, but not confined to, the following:

Launching a programme with the command 'open...'
Hunting for information online with the instruction 'search for...'
Accessing Wikipedia via 'Open Wikipedia page on...'
Engaging with ChatGPT using 'tell me...'
Scouting for images with the command 'search for images of...'

How can I use it?

Simply download the latest release from:

https://github.com/mxro/autohotkey-chatgpt-voice/releases

Instructions for installation can be found here

How it all works?

The following diagram shows the different steps this solution executes:

There are three crucial technologies at the heart of this solution.

AutoHotKey is an open-source program useful for creating Windows automations.
fmedia, a tool to record and manipulate sounds.
The 'whisper-autohotkey.exe', a bespoke application I created in Go for communication with the OpenAI API.

This is how they work together:

Step One: Launch an AutoHotKey script and allow it to idly monitor for F8 key strokes.
Step Two: Command Fmedia to begin recording sound when the F8 key is pressed.
Step Three: Instruct Fmedia to cease recording at the next F8 key press.
Step Four: Initiate the custom Go application, 'Whisper-AutoHotKey.exe'. Use it to dispatch the audio file recorded by Fmedia to OpenAI's Whisper API, thus getting it transcribed to text.
Step Five: Convey this transcribed text into the OpenAI Chat GPT API, generating an AutoHotKey script in the process.
Step Six: Run the AutoHotKey executable and input the fresh script, leading to the execution of the required action.

Further explanations detailing the functionality of each component and step are provided in the subsequent section.

AutoHotKey Watch Script

The watch script defines an action that is triggered whenever the user presses the F8 key.

F8::
  NotRecording := !NotRecording
  If NotRecording
  {
    Run %A_WorkingDir%\bin\fmedia-1.31-windows-x64\fmedia\fmedia.exe --record --overwrite --mpeg-quality=16 --rate=12000 --out=rec.mp3 --globcmd=listen,, Hide
  }
  Else
  {  
    Run %A_WorkingDir%\bin\fmedia-1.31-windows-x64\fmedia\fmedia.exe --globcmd=stop,, Hide
    Sleep, 100
    Run %A_WorkingDir%\bin\whisper-autohotkey\whisper-autohotkey.exe,, Hide
  }
  return

We first check whether we are currently recording or not. If we are not recording, we use fmedia to start the recording the command:

Run %A_WorkingDir%\bin\fmedia-1.31-windows-x64\fmedia\fmedia.exe --record --overwrite --mpeg-quality=16 --rate=12000 --out=rec.mp3 --globcmd=listen,, Hide

Notice here specifically the globalcmd=listen directive. This allows us to stop this recording through another invocation of fmedia.exe.

Also note the specific quality and sampling rate provided here - I fine-tuned this using a few experiments.

When F8 is pressed and we are currently recording, we use fmedia.exe to send the command to stop recording:

Run %A_WorkingDir%\bin\fmedia-1.31-windows-x64\fmedia\fmedia.exe --globcmd=stop,, Hide

We then give our operating system a little break to write out the recorded file and then run the custom executable whisper-autohotkey.exe.

Sleep, 100
    Run %A_WorkingDir%\bin\whisper-autohotkey\whisper-autohotkey.exe,, Hide

The next steps all happen in whisper-autohotkey.exe - a custom Go application I developed.

Transcribe

Within our Go application, we read out the recorded MP3 file and send it to the OpenAI Whisper API, see whisper.go:

func Transcribe(inputFileName string, config Config) (string, error) {
    c := openai.NewClient(config.OpenapiKey)
    ctx := context.Background()

    req := openai.AudioRequest{
        Model:    openai.Whisper1,
        Prompt:   "",
        FilePath: inputFileName,
    }
    response, err := c.CreateTranscription(ctx, req)
    if err != nil {
        return "", err
    }

    return response.Text, nil
}

We are using the OpenAI API Go SDK here.

Generate Script

Once we have received the transcription, we are calling the OpenAI API chat completion endpoint to generate our AutoHotKey script, see gpt4.go:

func BuildCommand(config Config, prompt string) (string, error) {

    if strings.TrimSpace(prompt) == "" {
        return "MsgBox, 32,, No input detected! Is your microphone working correctly?", nil
    }

    systemContext, err := os.ReadFile("./prompt.txt")
    if err != nil {
        return "", err
    }

    c := openai.NewClient(config.OpenapiKey)

    response, err := c.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: openai.GPT4,
            // https://github.com/sashabaranov/go-openai#why-dont-we-get-the-same-answer-when-specifying-a-temperature-field-of-0-and-asking-the-same-question
            Temperature: math.SmallestNonzeroFloat32,
            Messages: []openai.ChatCompletionMessage{
                {
                    Role:    openai.ChatMessageRoleSystem,
                    Content: string(systemContext),
                },
                {
                    Role:    openai.ChatMessageRoleUser,
                    Content: "ACTION: " + prompt,
                },
            },
        },
    )

    if err != nil {
        return "", err
    }

    return response.Choices[0].Message.Content, nil
}

Note, we provide most of the guidance for the GPT model here in the system context, which is provided by the following custom prompt (prompt.txt):

You are a Windows automation engineer that is very familiar with AutoHotKey.
You create AutoHotKey V1 scripts. I ask you to conduct a certain ACTION.
You then write a script to perform this action.

Unless otherwise specified, assume:

the default browser is Firefox
the default search engine is DuckDuckGo
if looking for pictures, open the pexels website
when I ask you to 'tell me X', output a script that shows a GUI window using MsgBox that provides the answer to X.
if no specific action is specified, assume a web search for the prompt needs to be conducted
Your answer must ALWAYS ONLY be a correct AutoHotKey Script, nothing else

Avoid all logical and syntactical errors. To help you avoid making errors, ALWAYS keep in mind ALL of the following rules:

The action should be executed when the AHK script is run, not define a keyboard shortcut to trigger the action.
You only respond with the script, don't include any comments, keep it as short as possible but ensure there are no syntax errors in the script and it is a correct AutoHotKey V1 script.
Tray tips are provided as follows 'TrayTip , Title, Text, Timeout, Options'.
When constructing URLs, ensure to escape the escape sequence for space (%20) as '`%20'.
Apply all AutoHotKey Escape sequences as required.
Replace all '%' characters in URLs with the correct escape sequence '`%'. E.g. '%20' with '%20
NEVER provide any other output than the script. Always complete the action with a 'return'.
If you are not sure what action needs to be taken or how to create a script to perform the action, create a script with the following content: > MsgBox, 32,,[Your comment] Replace [Your comment] with your comment. Also include the prompt as you have received it in the comment.
If I ask you to Paste something, use the SendInput, {Raw} function.

Now I will provide the ACTION. Please remember, NEVER respond with ANYTHING ELSE but a valid AutoHotKeyScript.

Note, you can easily customise this prompt after downloading this tool by editing the prompt.txt file in the tool folder. For instance, you may want to change the default browser to something else such as Chrome.

Execute Script

After we have generated the script, we then execute it using AutoHotKey, see ahk.go:

func RunCommand(config Config, script string) (string, error) {

    if err := os.WriteFile("script.ahk", []byte(script), 0666); err != nil {
        return "", err
    }

    autoHotKeyPath := config.AutoHotKeyExec
    if autoHotKeyPath == "" {
        autoHotKeyPath = ".\\bin\\autohotkey-1.1.37.01\\AutoHotkeyU64.exe"
    }
    data, err := exec.Command(autoHotKeyPath, "script.ahk").Output()
    if err != nil {
        return "", err
    }

    output := string(data)

    return output, nil
}

The generated script will, for example, look like follows:

Run, firefox.exe "https://duckduckgo.com/?q=Whisper`%20OpenAI`%20API`%20Go`%20SDK"
return

Learnings and Limitations

The following are the learning and remaining limitations of the developed tool:

The OpenAI Whisper API can occasionally seem temperamental, primarily due to the data uploading process and the subsequent processing duration.
There's a significant variance in latency, with the API requests sometimes taking up to ten times longer than the average duration. This is common with my basic, consumer-grade account.
GPT-4 fails to excel at writing AutoHotKey scripts, usually falling into basic logic or syntax traps. I tried to bypass some of these frequent blunders by giving the model extra guidance within the initial prompt. However, it struggled with character escaping - a common challenge within AutoHotKey. For example, the character '%' had to be escaped as '`%'.

Conclusion

It's safe to infer that Cortana Voice's capacity to control windows wasn't a hit, given its discontinuation.

Conversely, the tool detailed in this post has been quite useful to me. It's particularly useful for triggering web searches, bundling multiple steps into a straightforward voice command. This feature absolves me from typing out search queries.

In terms of disadvantages, the major one I've noticed in my personal use is the Whisper API's sluggishness. A noticeable delay ensues between issuing a command and waiting for it to be transcribed, passed to GPT, and finally executing the script. However, I was able to reduce latency by about 50% using some fine-tuning of the audio encoding settings used.

Further, it's worth mentioning that GPT-4 isn't always successful in concocting accurate Autohotkey scripts. My experience suggests approximately a 90% success rate. However, I'm optimistic that further refining the prompt can heighten the accuracy rate.

This tool been published as an open source project. I encourage you to contribute your observations or thoughts either by visiting the project or leaving a comment on this post.