Forem: Bas Steins

Stelvio's Anniversary: Ship Python to AWS

Bas Steins — Wed, 04 Feb 2026 12:06:04 +0000

Last weekend, we released our anniversary release of Stelvio.

Stelvio is an open source framework that allows you to create and deploy infrastructure to the Cloud, AWS in particular.

We support a wide variety of serverless services, including:

Compute: Functions are a first class citizen in Stelvio
Storage: S3 Buckets are fully integrated, including their notifications
Database: DynamoDB is a noSQL database fully supported by Stelvio
Schedules: Cron components let you execute code periodically
Topics and Queues
A Router component that unifies resources under the same domain
a configuration option to customize DNS using Route53 or Cloudfront.

In addition, we support

A live mode: You deploy your stack to AWS as normal but you can run lambda function code locally using a bridgte between your computer and the AWS infrastructure
Automatic set of permissions: When you link components, sensible defaults are created for IAM permissions and these are securely linked between your components.

Give it a try:

Watch our intro video:

And our celebration podcast:

My Year in Review: 2025

Bas Steins — Wed, 31 Dec 2025 11:34:34 +0000

What happened in 2025

I somehow managed to miss publishing a 2024 review. No grand reason. But here we are.

☕ Community

At the beginning of the year, I joined the torc.dev community. That decision set the tone for a lot of what followed.

Over the summer, I started a podcast: bas.fm — conversations with people in tech. No growth hacks, no "content strategy", just honest discussions with people I find interesting. By the end of the year, 26 episodes were out in the world. That alone still surprises me a bit.

I also attended Commit Your Code Conference in Texas, which was a refreshing reminder that flying across an ocean to talk to people in real life still beats any Discord server or Slack workspace. On top of that, I went to several local meetups — smaller, less polished, but often more meaningful.

Key takeaway:

2026 (and probably the years ahead) will be about personal connections more than ever.

We barely finished processing "the virus" years when AI slop arrived and flooded our timelines. Genuine connections to real people feel scarce — and therefore valuable.

⛰️ Stelvio

In spring, I joined Michal Martinka to work on Stelvio.

Stelvio is a Python framework for defining AWS serverless infrastructure in pure Python. No YAML, no DSLs pretending not to be programming languages.

Over time, we made solid progress and are aiming to move the project from alpha to beta early next year. One of the features I’m particularly excited about is the ability to run Lambda functions locally while they’re still part of real AWS infrastructure — no emulator required.

A lot of the work wasn’t just writing code. It was pair programming sessions, long discussions, trade-off analysis, and occasionally realizing that AWS has opinions you only discover once you trip over them.

For me, Stelvio has been a great way to stay involved in open source while also digging deeper into the less glamorous, more intricate parts of AWS. The parts that don’t fit neatly into blog posts or conference talks, but matter a lot in practice.

⚕️ Health

The growing attention around Bryan Johnson's "Don't Die" initiative—where he spends millions each year biohacking his age, complete with monthly colonoscopies—has made any talk of "biohacking" feel a bit cringe these days.

Still, I stuck with my supplement and workout routines. Winter made that harder than I’d like to admit, but nothing derailed completely.

It’s now been three years since I last saw a doctor for anything other than routine bloodwork. I feel fitter, stronger, and more energetic than I did ten years ago, which is still the only metric I really trust.

Key takeaway:

"Physical health is the foundation for everything that follows." I wrote that in my 2022 retro, and it still holds.

Tools used: whole foods, gym, supplements. I’ll probably write a separate post about the exact protocols at some point.

🌠 The Future

Work on Stelvio will continue, and I'm planning to focus more on sharing knowledge about AWS, especially tailored for Python developers. I'll keep going with the podcast, get fully back on track with my workout plan, and make a conscious effort to take more time off—just to do nothing.

🔮 Predictions

Some thoughts that will almost certainly age badly:

Europe will continue to underperform economically compared to the US.
AI and robotics will peak in late 2026. We already have powerful LLMs and humanoid robots making strides, but we'll likely hit a wall next year.
Expectations around AI will keep bouncing between hype and disappointment, especially when it comes to "general" intelligence.
On the brighter side, AI will get much better at structured tasks, like coding and accounting.
Attention spans will keep decreasing, and some form of AI-induced brain rot feels inevitable.

Bigger picture: Society and economies in the EU and US will shift significantly. The value of traditional knowledge and university degrees might decline further. Chinese EVs will become mainstream. Europe will face mounting financial troubles with welfare budgets. The US will continue grappling with de-dollarization trends. Asset and precious metal prices will rise, opening the door to potential financial bubbles. Overall, it feels like the cards are being reshuffled—populist movements rising in Europe, globalization hitting the West harder, non-Western economies gaining ground, job insecurity growing, and longstanding values like traditional education coming under real pressure.

None of this is new. It just feels more visible now.

Agent Mode With Third-Party Models in Copilot

Bas Steins — Tue, 15 Jul 2025 14:28:58 +0000

How to Use Third Party Models in GitHub Copilot Agent Mode

GitHub Copilot has become an indispensable coding assistant for millions of developers. While it's incredibly powerful out of the box, many developers wonder: "Can I use other AI models like Claude, GPT-4, or Grok with Copilot's advanced Agent Mode?"

The answer is yes – but it requires a clever workaround.

The Problem: Tool Support Limitations

OpenRouter is fantastic for accessing various AI models from OpenAI, Anthropic, and others on a pay-per-use basis. It's perfect for testing different models without committing to expensive subscriptions. You can use powerful models like:

Grok - X.AI's conversational model
Kimi K-2 - Moonshot AI's capable model

However, there's a critical limitation: GitHub Copilot's Agent Mode requires models to support function calling (tools), but OpenRouter's API doesn't announce tool support for its models.

This means that even though models like Claude and GPT-4 natively support function calling, Copilot won't enable Agent Mode when using them through OpenRouter.

The Solution: A Proxy Chain

The solution is elegant: create a local proxy chain that preserves tool calling capabilities while routing requests through OpenRouter.

Here's the architecture:

VSCode Copilot → oai2ollama (port 11434) → LiteLLM (port 4000) → OpenRouter → AI Models

The magic happens in three stages:

VSCode Copilot sends requests to what it thinks is a local Ollama server
oai2ollama translates Ollama API calls to OpenAI format
LiteLLM proxies OpenAI-compatible requests to OpenRouter
OpenRouter routes to the actual AI model providers

Throughout this chain, tool/function calling capabilities are preserved, enabling full Agent Mode functionality.

Setting Up the Proxy: Step-by-Step Guide

I've created an open-source project called copilot-ollama that handles all the complex proxy setup automatically.

Prerequisites

Before we start, make sure you have:

uv package manager installed
An OpenRouter API key (get one here)
VSCode with the GitHub Copilot extension

Installation

Clone the repository:

   git clone https://github.com/bascodes/copilot-ollama.git
   cd copilot-ollama

Set your OpenRouter API key:

   export OPENROUTER_API_KEY=your_openrouter_api_key_here

Start the proxy servers:

   ./run.sh

This single command starts both proxy servers and handles all the configuration.

Configure VSCode:
- Open VSCode settings
- Set github.copilot.chat.byok.ollamaEndpoint to http://localhost:11434
- Click "Manage Models" → Select "Ollama"
Start coding! 🎉

Your OpenRouter models are now available in Copilot Agent Mode with full tool calling support.

Customizing Available Models

The proxy comes with sensible defaults, but you can easily customize which models are available by editing the config.yaml file:

model_list:
  - model_name: claude-3-sonnet  # Name that appears in VSCode
    litellm_params:
      model: openrouter/anthropic/claude-3-sonnet  # Actual OpenRouter model

  - model_name: gpt-4-turbo
    litellm_params:
      model: openrouter/openai/gpt-4-turbo

  - model_name: kimi-k2
    litellm_params:
      model: openrouter/moonshotai/kimi-k2

Popular Models to Try

Here are some excellent models to experiment with:

Model	OpenRouter Path	Best For
Claude 3 Sonnet	`openrouter/anthropic/claude-3-sonnet`	Code generation and reasoning
GPT-4 Turbo	`openrouter/openai/gpt-4-turbo`	Latest OpenAI capabilities
Mixtral 8x7B	`openrouter/mistralai/mixtral-8x7b-instruct`	Fast open-source model
Llama 3 70B	`openrouter/meta-llama/llama-3-70b-instruct`	Meta's powerful open model

Why This Matters

This solution opens up exciting possibilities:

Cost Control: Pay per use instead of monthly subscriptions
Model Diversity: Access to cutting-edge models from multiple providers
Full Agent Mode: Complete tool calling and function support
Local Control: Everything runs locally, maintaining privacy

Technical Details

For those interested in the implementation details:

The proxy uses LiteLLM for OpenAI-compatible proxying
oai2ollama handles Ollama API compatibility
Tool calling metadata is preserved throughout the proxy chain
The solution works around VSCode's current limitation of only supporting Ollama endpoints for custom models

Looking Forward

There's an ongoing discussion about enabling custom API endpoints directly in Copilot: microsoft/vscode-copilot-release#7518. Once that's implemented, this workaround won't be necessary.

However, until then, this proxy solution provides a robust way to unlock the full potential of GitHub Copilot with your favorite AI models.

The restrictions of the Copilot API can be found in the VSCode Copilot source code, which is where I discovered the Ollama endpoint configuration option.

Get Started Today

Ready to supercharge your coding experience? Check out the copilot-ollama repository and start experimenting with powerful AI models in GitHub Copilot's Agent Mode.

Vibe Coding a VSCode Extension

Bas Steins — Fri, 11 Jul 2025 16:23:17 +0000

Building a VSCode Focus Extension: An AI-Assisted Coding Journey

Recently, I stumbled upon a tweet by Will McGugan that caught my attention. The tweet showcased iA Writer's focus function—a clever feature that highlights the current "block" (or paragraph) while dimming everything else around it.

Since I'd never tackled VSCode extension development before, this seemed like the perfect opportunity for some experimental "vibe coding." The concept was simple enough: create something similar for code editors, but instead of paragraphs, focus on code blocks and symbol hierarchies.

tl;dr

I built a VSCode extension that dims code based on cursor location using AI assistance. Key takeaways: Used "meta-prompting" (AI helping write prompts for AI), spent ~$0.50 for 291 lines of code, discovered the FoldingRangeProvider API, and learned that AI excels at boilerplate but struggles with integration challenges. The extension works by leveraging DocumentSymbolProvider to create progressive dimming effects based on symbol hierarchy.

The Meta-Prompt Approach

Rather than diving straight into code, I decided to craft a comprehensive prompt first. Eventually, ChatGPT came up with this prompt:

< BEGIN OF PROMPT >
Prompt:

Build a Visual Studio Code extension named "VSCode Focus" that enhances code readability by dynamically dimming unrelated code based on the cursor’s location in the document's symbol hierarchy. The extension should implement the following behavior:

🔍 Behavior:

Symbol Hierarchy Detection

Use the DocumentSymbolProvider to retrieve the hierarchical structure of the open document.
Parse the symbol tree to determine which symbols contain the current cursor position.
Identify the full path of nested symbols from the outermost to the innermost level where the cursor resides.

Dynamic Opacity Calculation

Apply a progressive dimming effect:
- Innermost symbol (cursor location): 100% opacity (no dimming).
- Each parent level: Reduce opacity by a configurable opacityIncrement.
- Code outside the symbol hierarchy: Dimmed to a configurable minimumOpacity.

Optional Block Support

If vscode-focus.includeBlocks is true, include blocks like if, while, for, switch, etc., in the hierarchy analysis using AST or custom parsing.

Live Updates

Automatically update dimming effects as the cursor moves or the file content changes.

⚙️ Configuration (via Settings UI):

"contributes": {
  "configuration": {
    "title": "VSCode Focus",
    "properties": {
      "vscode-focus.enabled": {
        "type": "boolean",
        "default": true,
        "description": "Enable/disable the focus highlighting effect."
      },
      "vscode-focus.minimumOpacity": {
        "type": "number",
        "default": 0.1,
        "minimum": 0.01,
        "maximum": 0.9,
        "description": "Minimum opacity for the outermost dimmed code."
      },
      "vscode-focus.opacityIncrement": {
        "type": "number",
        "default": 0.2,
        "minimum": 0.05,
        "maximum": 0.5,
        "description": "Opacity increment per hierarchy level."
      },
      "vscode-focus.includeBlocks": {
        "type": "boolean",
        "default": false,
        "description": "Include control flow blocks like 'if', 'while', etc., in focus detection."
      }
    }
  }
}

🎨 Implementation Notes:

Use the TextEditorDecorationType API to apply dimming styles to ranges.
Use debounce when handling cursor change or document edits for performance.
Respect multiple cursors but apply dimming based on the first/main selection.
Provide a command Toggle VSCode Focus to quickly enable/disable the effect.

< END OF PROMPT >

As you can see, this prompt was itself generated by an LLM. After several iterations with ChatGPT (gpt-3.5), it produced this fairly comprehensive specification. I'm still debating whether to call this approach "vibe prompting" or "meta vibe coding"—but whatever the name, it felt like a natural way to bridge the gap between a vague idea and executable requirements.

From Vision to Specification

The inputs I fed into ChatGPT were refreshingly simple: a screenshot from a similar extension and some ASCII art sketching out my vision.

And this ASCII art that captured what I had in mind:

// hierarchy 1 (inactive)
    LEVEL 1             60% DIM   = OPACITY 40%
    LEVEL 1             60% DIM   = OPACITY 40%

// hierarchy 2 (the active hierarchy)
    LEVEL 1             60% DIM   = OPACITY 40%
    LEVEL 2            40% DIM   = OPACITY 60%
        LEVEL 3        20% DIM   = OPACITY 80%
        LEVEL 3        20% DIM   = OPACITY 80%
            LEVEL 4    NO DIM    = OPACITY 100%  ← Cursor is here
            LEVEL 4    NO DIM    = OPACITY 100%

// hierarchy 3 (inactive)
    LEVEL 1             60% DIM   = OPACITY 40%

The concept was straightforward: create a gradual dimming effect where the current code context (method, class, namespace) remains fully visible, while surrounding code fades progressively based on how far removed it is from the cursor's current location.

The Development Experience

Armed with this detailed prompt, I put it to work with both GitHub Copilot and Claude Sonnet 4. The results were... educational.

Getting Started: The Activation Struggle

The initial setup was surprisingly smooth—both AI assistants generated reasonable starting code that followed the specification. However, getting the extension to actually activate proved trickier than expected. It took several "still not working" follow-up prompts before the code became truly functional. There's something humbling about watching an AI struggle with the same activation issues that trip up human developers.

The Mess Factor

During development, Copilot developed some interesting habits. It generated numerous test files that weren't actually needed, then forgot to configure the TypeScript compiler to ignore them. This created a cascade of build errors that took time to untangle. Even more amusing was its tendency to create an "incredible amount of markdown files"—apparently its way of keeping notes on the development process. These digital breadcrumbs painted a picture of an AI trying to maintain context across a complex task.

The Dimming Logic

Like an intern, the AI initially struggled with the core logic of applying the dimming effect. It got the logic right in of of the first prompts, but then applied the rendering logic from the inside (deepest symbol level) to the outside (outermost symbol level). While that sounds logical, the result was that the later applied dimming effects would override the earlier ones. And since symbols can nest deeply, this led to messed up visual results.

Technical Discoveries

From an implementation standpoint, the AI made some smart architectural choices. As expected from the original prompt, it leveraged the DocumentSymbolProvider—essentially tapping into the Language Server Protocol's understanding of code structure. This was the obvious foundation for any symbol-hierarchy-based dimming system.

The more interesting development came when I pushed to extend the dimming beyond just symbols (classes, functions, etc.) to include logical blocks like if, for, and switch statements. Copilot suggested investigating the FoldingRangeProvider, which was completely new to me. This was genuinely insightful—the folding provider already understands code structure in a way that could complement symbol analysis. Unfortunately, despite the solid theoretical foundation, we never quite got this extended functionality working reliably.

The Economics of AI-Assisted Development

Running this experiment provided some interesting data points on the practical costs of AI-assisted coding.

I kept everything within a single session, which meant that at some point the conversation history got compressed to manage context limits. According to the AI's own accounting, the entire project consumed roughly 60,000 input tokens and 20,000 output tokens—translating to about $0.50 in total costs.

The final extension weighs in at 291 lines of code, which works out to approximately 0.17 cents per line. I'm not sure this metric means much in isolation, but it's an interesting data point for anyone thinking about the economics of AI-assisted development. Of course, this doesn't account for the value of learning, experimentation, or the time saved compared to building from scratch.

Reflections

This experiment highlighted both the potential and limitations of current AI coding assistants. They excel at generating boilerplate, suggesting architectural patterns, and even discovering APIs you might not know about. But they still struggle with the integration challenges that often make or break real-world projects.

The meta-prompting approach—using AI to help craft better specifications—feels like it has real potential. Starting with a well-structured prompt led to much better initial code than my usual approach of jumping straight into implementation details.

Most importantly, this wasn't just about building a VSCode extension. It was about exploring a new way of working with AI tools, treating them as collaborative partners in both the design and implementation phases of software development.

When the Internet Melted Down: Cloudflare’s Outage and the Magic of Durable Objects

Bas Steins — Fri, 13 Jun 2025 14:30:52 +0000

If you were online yesterday, June 12, 2025, you might have noticed things got a little… chaotic. Cloudflare, the superhero of internet infrastructure, hit a snag that left a colorful mess (pun intended—check out that awesome image above!) across the web. Let’s dive into what happened during this 148-minute outage, why it mattered, and take a deeper look at the fascinating tech behind it—Durable Objects.

The Outage That Shook the Web

Yesterday, Cloudflare’s lights flickered, and it wasn’t just a minor glitch. For 148 minutes (that’s 2 hours and 28 minutes, to be exact), services like Workers KV, WARP, Access, and even parts of the Cloudflare Dashboard went dark. This wasn’t a small hiccup—Cloudflare handles over 25 million HTTP requests per second and boasts a network spanning 330 cities across 125 countries. When it stumbles, the internet feels it.

The culprit? A failure in the underlying storage infrastructure for Workers KV, a key component for many Cloudflare services. Workers KV is designed as a “coreless” service, meaning it should run independently across Cloudflare’s global data centers with no single point of failure. However, it relies on a central data store for a “source of truth.” When that store—tied to Google Cloud—went down, it triggered a cascading effect. Yep, Google Cloud’s outage yesterday amplified the chaos, impacting not just Cloudflare but the countless websites and apps depending on it for CDN and web firewall services.

Cloudflare’s CTO, Dane Knecht, owned up to it, promising a detailed postmortem (which they’ve already started drafting—kudos for transparency!). The outage wasn’t just a tech fail; it sparked a bigger debate about relying on hyperscalers, a point DHH hammered home in his own X posts about returning to bare metal.

Why This Matters

With Cloudflare powering a huge chunk of the internet, this outage had real-world impacts. Teams worldwide scrambled as their websites lagged or went offline. The dependency on third-party providers like Google Cloud raised eyebrows—why would a company with 330 data centers lean on someone else’s infrastructure? Bas speculates it’s a trade-off: Cloudflare’s all-in on its Workers platform and Durable Objects, but building a fully independent distributed file system might stretch their engineering resources thin. Fair point! This incident is a wake-up call to balance convenience with resilience, especially when the internet’s original DARPA design aimed to survive nuclear strikes.

Diving into Durable Objects: The Tech Behind the Scenes

Now, let’s geek out a bit! The YouTube video gives us a great starting point to unpack Durable Objects, the innovative tech at the heart of this outage. These are Cloudflare’s secret sauce for building stateful serverless applications, and they’re pretty cool once you get under the hood.

What Are Durable Objects?

Durable Objects are a compute-with-storage building block in Cloudflare’s serverless ecosystem. Unlike traditional serverless functions that are stateless (they forget everything after each run), Durable Objects let you keep state—think of them as persistent JavaScript objects that stick around and can be accessed anywhere in Cloudflare’s network. They run on V8 isolates, the same engine powering Google Chrome, with each isolate acting like a browser tab—isolated but capable of holding data.

How Do They Work?

Here’s the magic: when you define a Durable Object in your code, it looks like a regular JavaScript class. But Cloudflare handles the heavy lifting—spinning it up, persisting its state, and syncing it across their global network. Each Durable Object is tied to a specific location, and synchronization ensures consistency. This is where things get interesting (and a bit tricky). The persistence and syncing rely on underlying storage, which, in this case, looped back to Google Cloud. When that link broke, the whole chain faltered.

Durable Objects vs. D1

Cloudflare also offers D1, a serverless SQLite database built on Durable Objects. D1 is great for relational data but isn’t colocated with your application code, which can add latency. Durable Objects, on the other hand, give you low-level control with embedded SQLite, perfect for distributed systems. The trade-off? You might need to build custom database tools, unlike D1’s out-of-the-box features. It’s a choose-your-own-adventure scenario based on your app’s needs!

The Zero Cold Start Promise

One perk of Durable Objects is their near-zero cold start times. Since they load during the TLS handshake, your code is ready to roll almost instantly—unlike some serverless platforms (cough, AWS Lambda, cough) where cold starts can slow things down. However, if a Durable Object isn’t busy, it might get evicted from memory, making in-memory caching less useful unless it’s handling heavy traffic.

Lessons Learned and Looking Ahead

Cloudflare’s response was solid—frequent status updates and a commitment to fix the root cause. Their postmortem will likely dive into decoupling from upstream dependencies like Google Cloud, a move that could bolster resilience. For developers, this is a nudge to weigh the pros and cons of third-party services. Want scalability and zero cold starts? Great! Just don’t put all your eggs in one basket.

As for Durable Objects, they’re a game-changer for stateful serverless apps, especially with AI agents and distributed systems. But this outage highlights the need for redundancy in their storage layer. Maybe we’ll see Cloudflare roll out a homegrown solution—fingers crossed!

Projects

more-itertools – More routines for operating on iterables, beyond itertools
autokitteh – Durable workflow automation in just a few lines of code
tariff – The GREATEST, most TREMENDOUS Python package that makes importing great again
django-action-triggers – Django library for asynchronously triggering actions in response to database changes
maestro-cli – command-line tool to play songs (or any audio, really) in the terminal

Cloudflare Dev Week 2025: Revolutionary Serverless

Bas Steins — Sat, 12 Apr 2025 11:47:15 +0000

Clouflare is an interesting case for cloud-native (for lack of a better word) software developers. They're still primarily known for their CDN only, and it seems that they slept through the whole serverless development thing that Azure, Google, and AWS is pushing.

Nothing could be further from the truth. With workers, durable objects, serverless KV-stores and SQLite databses, you could build almost everything imagineable on their platform.

This year, however, they're really doubling down on the developer experience.

Here are the most impressive announcements Cloudflare made during their Developer Week 2025 event:

Full-Stack In A Single Worker

With the support of static assets in Workers, you can now deploy a full-stack application in a single worker. Basically, this is an effort to merge Workers and Pages into a single product.

Additionally, Workers now support popular frameworks such as React Router v7 (Remix), Astro, Hono, Vue.js, Nuxt, and SvelteKit, with upcoming support for Next.js, Angular, and SolidJS (SolidStart) expected in Q2 2025.

Additionally, Cloudflare has upgraded its Agents SDK to better support AI agents using the Model Context Protocol (MCP). This update streamlines remote transport, authentication, and tool discovery, enabling AI agents to securely and efficiently interact with multiple MCP servers. By integrating with authentication providers like Stytch, Auth0, and WorkOS, Cloudflare ensures robust security while providing the scalability needed for complex AI workflows. With Durable Objects available in its free tier, Cloudflare now offers scalable, stateful storage solutions essential for modern AI applications.

Blog Post

0.email

In a surprising yet timely move, the one-day-old launch of 0.email—a complete email service running entirely on Cloudflare’s infrastructure—demonstrates just how far the platform has come. This project is a testament to Cloudflare’s commitment to challenging conventional service paradigms and pushing the limits of what’s possible at the edge.

Summary

Cloudflare Developer Week 2025 could mark a turning point for the company, shifting its image from a niche CDN provider to a formidable player in the serverless landscape. By stripping away the heavy-handed legacy of traditional enterprise cloud offerings, Cloudflare has focused on delivering a modern, hassle-free platform that champions developer experience above all else. With robust support for full-stack deployment, advanced database integrations, powerful orchestration tools, and even containerization, Cloudflare is poised to disrupt the serverless space. For developers tired of the complexities and overhead of traditional microservices architectures and Kubernetes, Cloudflare's streamlined, developer-first approach is a breath of fresh air and the future of software development.