Plan B: cloud API keys. Simpler, works, costs less than $2 per attendee. Now I need to hand out 150+ keys without triggering a new class of problems.

So I built a custom minter through a simple web app in Typescript.

The key-distribution problem

3 options, all bad:

1. One shared key. Anyone leaks it, burns the budget, no per-attendee accounting.

2. Attendees create their own account on the day. 5-15 minutes gone to credit card entry, verification emails, and “my phone number doesn’t work”. Some drop out because they won’t hand a card to OpenAI or Anthropic. Conference time is precious.

3. Pre-create keys and hand them out on cards... Maybe as swag, but can you really see attendees copying a long hash off a card?

What I actually want:

• Per-attendee key, minted on demand through sign-up

• Hard budget cap per key (e.g. $2 each)

• Hard budget cap for the whole workshop (in case one fun person spins up 20 emails), with a clear “first come, first served” signal

• Model allowlist (no burning the workshop pool on GPT-5 for fun)

• Open claims at a given time and auto-expiry after the workshop

• Whole flow should take less than a minute for the attendee

OpenRouter

OpenRouter is a single OpenAI-compatible API in front of every major provider.

You fund your account once, pick models by their slug (anthropic/claude-sonnet-4.6, openai/gpt-5-nano, ...), and they handle the billing split behind the scenes.

The feature that makes this work is the Management API (formerly called provisioning keys). With a management key, you can programmatically:

• Mint sub-keys, each with their own limit (USD) and expires_at

• Disable a key individually

• Read per-key usage

That covers bullets 1, 2, and 4 from the wishlist. Bullet 3, the model allowlist, is where I got tripped up.

Note : Hugging Face has an analogous routing layer called Inference Providers. It’s OpenAI-compatible (router.huggingface.co/v1), fronts 20+ providers (Together, Fireworks, Groq, Cerebras, Replicate, SambaNova, OpenAI, etc.), and supports provider-selection policies: :cheapest, :fastest (default), :preferred (changelog). For a workshop though, the minter story is weaker: you work with fine-grained user tokens and a monthly credit bucket.

allowlists aren’t a key-level setting

I assumed per-key settings would cover everything. They don’t. A key carries a budget and an expiry. The model allowlist lives on a separate object called a Guardrail.

To OpenRouter folks reading this: worth adding a callout about Guardrails on the API-key creation flow. I struggled to understand the model at first.

One Guardrail per workshop:

{
  "name": "workshop-pyconde-2026-darmstadt-sql-agents",
  "limit_usd": 800,
  "reset_interval": "monthly",
  "allowed_models": [
    "anthropic/claude-sonnet-4.6",
    "openai/gpt-5-nano",
    "qwen/qwen3.5-flash-02-23"
  ]
}

Keys get bulk-attached to the Guardrail after mint. OpenRouter then enforces the allowlist and the aggregate cap on every request.

Gotcha that cost me another 10min: the Management API treats guardrail attachment as a separate resource from key creation. The POST /keys payload will happily accept a guardrail_ids field and return a 200, but the key lands unbound. You have to make a second call, POST /guardrails/{id}/assignments/keys, with the key hashes. Nothing in the docs warned me; I only noticed because attendees were hitting models I hadn’t allowed.

The server-side mint flow ends up as three API calls:

const g = await ensureGuardrail({
  name: `workshop-${slug}`,
  limit_usd: workshop.openrouter.guardrail.cap_usd,
  allowed_models: workshop.openrouter.models.map((m) => m.id),
});
const key = await createKey({ name, limit, expires_at });
await assignKeysToGuardrail(g.id, [key.data.hash]);  // the one that matters

If the third call fails, the attendee still gets a working key (just unenforced) and the admin dashboard flags the row as “unbound” with a retry button. Best-effort on a non-idempotent API call.

YAML as workshop config

One file per workshop in workshops/<slug>.yaml. PR + merge + redeploy = new workshop live (when claims open) to be minted.

The Darmstadt one, trimmed:

slug: pyconde-2026-darmstadt-sql-agents
name: "SQL is Dead, Long Live SQL: Engineering reliable analytics agents from scratch"
event: PyConDE & PyData Darmstadt 2026
location: Dynamicum [Ground Floor]
starts_at: 2026-04-14T11:45:00+02:00
ends_at:   2026-04-14T14:45:00+02:00
claims_open_at:  2026-04-13T18:00:00+02:00
claims_close_at: 2026-04-14T15:00:00+02:00
is_active: true

welcome_message: |
  ## SQL is Dead, Long Live SQL 🦆
  Workshop by **mehdio** & **dumky** at PyConDE & PyData Darmstadt 2026.
  You'll get a personal workshop API key loaded with $2 of credit.

openrouter:
  budget_usd: 2.0
  key_label_prefix: pyconde-2026-darmstadt
  expires_buffer_minutes: 30
  models:
    - id: anthropic/claude-sonnet-4.6
      label: Claude Sonnet 4.6
      note: Best for the agent loop — pricier but smarter
      price_in_per_mtok: 3.00
      price_out_per_mtok: 15.00
    - id: openai/gpt-5-nano
      label: GPT-5 nano
      note: Cheapest, fast iterations
      price_in_per_mtok: 0.05
      price_out_per_mtok: 0.40
  guardrail:
    cap_usd: 800
    reset_interval: monthly

max_keys: 300

The models list is the single source of truth. It renders the pricing table on the workshop page, seeds the code-snippet tabs on the “your key” view, and drives the Guardrail’s allowed_models. One place to edit when you swap models.

claims_open_at and claims_close_at mean nobody mints a key the day before the workshop, and once the session ends + 30-minute buffer. No cron to disable the minter.

The data model

Some data was worth storing in a dedicated Postgres, emails first (yup, it’s a lead-capture asset too, fair trade right? 😈).

Two tables. That’s it.

create table attendees (
  user_id          text primary key,   -- Auth0 sub, e.g. 'google-oauth2|abc123'
  email            text not null,
  email_normalized text not null,      -- +tag stripped, Gmail dots removed
  display_name     text,
  auth_provider    text not null,      -- 'google' | 'github' | ...
  marketing_opted_in            boolean not null default false,
  marketing_opted_in_at         timestamptz,
  marketing_opted_in_workshop   text,  -- slug where consent was given
  first_seen_at    timestamptz not null default now(),
  last_seen_at     timestamptz not null default now()
);

create table workshop_attendance (
  user_id               text not null,
  workshop_slug         text not null,
  or_key_hash           text not null,
  or_key                text not null,  -- plaintext, on purpose (see below)
  key_label             text not null,
  limit_usd             numeric not null,
  expires_at            timestamptz not null,
  or_guardrail_id       text,
  guardrail_attached_at timestamptz,
  usage_usd             numeric not null default 0,
  usage_synced_at       timestamptz,
  attended_at           timestamptz not null default now(),
  primary key (user_id, workshop_slug)
);

Two choices worth calling out:

The key is stored plaintext. OpenRouter shows the key exactly once at mint time. If I hash it, the attendee who refreshes their browser is locked out. Blast radius of a DB leaking is bounded: every key is capped at $2, expires 30 minutes after the workshop, and only works against the Guardrail’s allowed models. Rather take that trade than deal with 30 “I lost my key” DMs during the session.

Other gotcha: I was pulling API key usage live, but the UI and the API expose it through different endpoints. Better to save usage to the DB, then you can easily show how much each project consumed.

Demo

Home page when an active workshop is on. The user clicks to sign in and claim a key.

The workshop page:

Once logged in, the user sees the authorized models, their prices, and code snippets to get started.

And the admin view of the Guardrail on OpenRouter: allowed models and monthly cap in one place.

Build your own!

It’s a small project with some MotherDuck-specific bits (brand, auth provider, etc).
But with the info in this post, any AI coding agent can scaffold a version from the prompt here.

Key design takeaways:

1. YAML per workshop in the repo, bundled at build time. Pull requests are the admin UI.

2. OpenRouter Management API for key minting. One funded account, programmatic sub-keys.

3. Guardrails for the allowlist, not per-key settings. And remember the separate assignments/keys call: POST /keys silently ignores guardrail_ids.

4. Sign-in (any OIDC provider). The email confirmation step doubles as a consent moment for a marketing opt-in.

5. Store the key plaintext. Blast radius is bounded by budget + expiry + guardrail. Hashing creates a support problem, not a security win.

Conclusion

Another company running a workshop at the same PyCon, tower.dev, hit exactly this challenge and built a near-identical solution in parallel. Two data points is a pattern: a branded page with real auth, per-attendee bounded keys, and admin visibility is now table stakes for any AI or agent workshop. “Print 100 keys and hand them out” doesn’t cut it past about 10 attendees.

If you’re prepping an agent workshop for 2026: build the minter first. Budget one afternoon with an AI coding agent and this post.

The code is (now) the boring part.

Been watching GitHub struggle lately. Michael Driscoll posted about their service getting shredded by automated agents running 24/7. Cloud services weren’t built for this kind of constant hammering.

Tomasz Tunguz at Theory Ventures wrote about the coming AI compute crisis: real scarcity by 2026, with only the big players able to afford the best models while startups get stuck with slow service and high prices.

Makes you rethink the whole “democratized AI” story.

🛠️ VibePod + Caveman: two agent tools worth a look

VibePod CLI: Simple way to run AI coding agents in isolated Docker containers. No setup, just vp run <agent>. Built-in analytics to compare agents side by side. The isolation model is smart: keeps your system clean while you experiment. Been wanting exactly this.

Caveman skill for Claude: Why use many token when few token do trick? Cuts 75% of tokens by making Claude talk like caveman. Removes all the pleasantries and filler, keeps technical accuracy. Brilliant for API costs when running agents at volume. (Yes, the irony of an AI talking like a caveman to save resources is not lost on me.)

🧠 Software engineer burnout because of AI

There’s a real paradox happening. Software engineers are scared of their jobs being taken, and at the same time excited to build things they would never have been able to build before.

But there’s another part to the story: craving the coding skills you’ve been honing for years.

I was at PyCon last week and heard the same thing from AI power users: they’re burnt out. Our brains aren’t designed to juggle 4+ agents in parallel. You’re incredibly productive, but exhausted. And you miss the joy of writing code yourself, failing for hours on a syntax issue, then getting the lightbulb moment. Some engineers (e.g. Simon) are “downgrading” on purpose: learning a new language without autocomplete, writing on paper or e-ink, cutting screen time.

This resonates with some well-known figures in software engineering:

DHH on the My First Million podcast:
“the last 3 months I’d say has been the most churn in my mental approach to computers in the entire time I’ve been using them.”

Simon Willison on Lenny’s podcast :
“Using coding agents well is taking every inch of my 25 years of experience as a software engineer, and it is mentally exhausting.”

Agentic coding can be a real addiction, and with any real addiction come some negative side effects.

🛠️ claude status in terminal

I’ve been IDE-free for ~2 months, living in Claude Code / opencode + tmux (deserves its own post). Recently I wanted better status handling to see when Claude is busy vs. waiting on my input.

I landed on two projects: opensessions (heavier, TypeScript extension) and tmux-agent-status (pure bash). Tried both, but ended up “stealing” the best ideas and adapting them to my own setup, simpler and works better.

Here’s what it looks like, and my dotfiles are here if you want to get inspired for your own setup!

📚 What I read/watched

• “You’re right to be anxious about AI, this is how much we are building” by Dumky de Wilde: the GitHub/package/paper growth charts since early 2025 are absurd. Your anxiety is rational.

• “Using coding agents well is taking every inch of my 25 years of experience” via Lenny Rachitsky: agent orchestration is its own skill and nobody is good at it yet.

• “Vibe Coding Kills Open Source”: as AI gets better at generating code, contributions back to the libraries drop. Who maintains the stack when everyone’s just prompting?

• “This guy built a $1.8B company with 2 employees”: telehealth shop running marketing, support, and creative through AI. The per-employee economics are getting weird.

• $100M+ Advice That’ll Piss Off Every Business Guru (ft. DHH)DHH on one of my favorite business podcasts!

• Claude HowTo: visual, example-driven Claude guide with copy-paste templates. Good starting point if you’re finally getting serious with it.

PyconDE last week! Above the talks, what’s always nice is to connect randomly with folks and share knowledge and experience.

🧠 AI hurts learning without helping productivity (for new skills)

Anthropic researchers released an interesting paper last February: “How AI Impacts Skill Formation”.

They ran an experiment on 52 Python developers learning a new async library (Trio). The AI-assisted group scored 17% lower on the post-task quiz while completing the task in roughly the same time as the no-AI group. No speed gain but a real learning cost.

You can probably guess why if you’ve been in this situation: you spend too much time prompting the AI trying to figure out what you actually want, especially when you can’t assess what’s being produced because you don’t have the foundations.

This is cognitive delegation. If you’re learning something new on the job and using AI to do it for you, you’re becoming a weaker engineer over time.

As a DevRel, these findings matter a lot. I’m teaching people how to use AI and how you use it shapes not just productivity but long-term learning. That’s the part most people are missing.

🛠️ Obsidian CLI & headless client

Obsidian recently released two tools:

• A CLI

• A headless client

The headless client is interesting. It means you can now let agents write to your vault separately from your laptop, like in CI. Combined with sync, you could run auto-tagging in a pipeline and have it pulled to your laptop or mobile the next time you open the vault.

The CLI is more pragmatic. I’ve been using Claude Code alongside Obsidian thanks to the community terminal extension, and the CLI makes common vault operations faster and cheaper on tokens because it’s built around specific patterns you’d otherwise rewrite from scratch every time with bash.

Someone did a benchmark and the speed gain isn’t massive even on a large vault, but it adds up:

There are also many other commands available like plugins. I’ve been using Claude Code to fix things around my setup: finding the right plugins, tweaking their config. Works great.

🧠 Your IP is not the code, it’s your workflows

I’ve been spending a LOT of time improving my workflows with AI.

Whether it’s figuring out which MCPs are actually useful, turning repetitive tasks into skills, or automating pipelines that would’ve taken too long to do manually and this is where I’ve been putting my energy. One big piece: all my content is now a hub on mehdio.com with stats updated daily.

I think this is what “finding your craft” looks like in the AI era : taking every workflow and shaping it to your taste, your needs, and your creativity.

One great blog in these lines that resonate with me is one from , I Haven’t Written a Line of Code in 4 Months (But I Ship More Than Ever). Kaxil is a committer and PMC member of the Apache Airflow project and he’s sharing the shift that has happened for him in terms of development and workflows specifically with a lot of insightful tips : a must read!

“Models haven’t improved much. Harnesses are what changed. If you’re investing in AI coding, invest in the harness.”

🛠️ More metadata for Claude Code

CShip is a nice little plugin for Starship that shows more information about Claude Code. I was already a Starship user, so adding this was a no-brainer. At least now I can see when I’m burning too much $$.

🧠 AI security and skills

We’ve heard wild stories with MCP servers, people going overboard on permissions and what they allow. But recent attacks on skills are also worth paying attention to.

Skills are just markdown, so they’re easy to inspect but many people use them without reading them, which hands over both security and control over their systems.

One example (among many): a supply chain attack on a Claude skills marketplace : a fake skill called “What Would Elon Do” was published by someone named Jameson. Separately, Vercel’s tooling was automatically finding and downloading skills based on what users asked, meaning a malicious skill only needs to be published once to get auto-executed across users’ systems.

Skills have been growing fast:

Always review and understand skills before running them.

🛠️ Disappointing Google CLI

Everyone’s shipping a CLI these days and for good reason. Agents love CLIs and bash execution. One promising recent addition was the Google Workspace CLI. Could we finally get a smooth experience with Google Docs for collaborating with teammates and AI?

Short answer: not really.

Setup is rough. You need a Google developer project account (fine), but then you have to configure specific auth tokens AND authenticate through the usual GCP project maze.

And the Google Docs experience itself was underwhelming. The API sees documents mostly as one block of text so targeted edits, handling specific comments, anything contextual was a poor experience.

Then it hit me: CLIs are just another surface for existing APIs. Bad API, bad CLI.

Good API for collaborative docs? Notion. I’m an Obsidian user at heart, but I’ve been leaning on Notion as a knowledge layer for work done with Claude and updating pages, responding to comments, all of it is smooth. And because it has structured components like databases, it’s great as a lightweight internal UI too.

Point to Notion.

📚 What I read/watched

Articles

• Your Data Agents Need Context by a16z: context is the problem, not the model. been saying this for a while.

• AI and the Mixed-Consistency Future by Joe Hellerstein: dense one. but if you’re building on top of AI in a distributed system, you need to read this.

• Manipulating AI memory for profit: The rise of AI Recommendation Poisoning by Microsoft Security: nobody’s talking about this yet and they should be.

• SQL Is Solved. Here’s Where Chat-BI Still Breaks. by Julien Hurtevent: everyone’s excited about Chat-BI until they hit the edge cases. this is where it breaks.

• Moats in the Age of AI by CJ Roth: code is not your moat anymore. good articulation of where defensibility actually is now.

• The Last Mile is Solved by Slop by dlt Hub: the ugly ETL nobody wanted to write? AI just does it now. slop that ships > perfect code that doesn’t.

• AGENTS.md outperforms skills in our agent evals by Vercel: worth reading if you’re building with agents, structured context in a file > trying to prompt your way around it.

• The Semantic Layer Is Back. Here’s What We’re Doing About It. by Preset: it comes back every few years. this time AI is the reason and it makes more sense now.

Videos

• I Let 30 AI Agents Loose in My Repo (Gas Town): watching 30 agents run loose on a real codebase is as messy as it sounds. you learn a lot from the chaos.

• Anthropic killed Tool calling: don’t let the title fool you it’s actually a decent explainer on what changed with MCP.

• Should You Learn Coding Now? Anthropic CEO Explains: headlines butchered this one. watch the actual clip.

• An AI CEO finally said something honest...: short. rare moment of honesty in a sea of hype.

• Is SaaS actually dead? (...no): SaaS is not dead. great reality check.

• AI agent design patterns: practical patterns, not theory. good reference.

• Be Careful w/ Skills: video version of what I covered in the security section above.

In reality, babies are a lot like Pokémon. Except they only take a week to evolve, and a few months before you can even narrow down what type they are...

I’ve been using Cursor as my IDE, and I’ve realized that I barely use most of its features anymore—simply because I’m writing less code manually.

I think IDEs can afford to be much more lightweight when it comes to editing features. Instead, they should be designed around agents, workflows, and review. GitHub actually feels closer to this setup already. You have an Agent tab, you can orchestrate tasks through GitHub Actions, review through PRs, and spin up a Codespace that’s sandboxed to your repository.

I can even imagine “projects” becoming a way to launch agent tasks and track their progress.

So yeah, in the long run, I think GitHub is well positioned here. Editors built on VS Code are going to have a hard time—or will need some drastic changes.

🛠️ Deepfakes are too easy now

Last week I had to get creative for some marketing content. If you haven’t seen it:

Beyond being a fun experiment, it gave me a firsthand look at the challenges involved. How good and easy is it to create a deepfake?

First, you have to realize that most platforms have security checks—so deepfaking a celebrity is harder if you’re not using open-source tools. At least, that’s what I thought.

Turns out, many of these tools have barriers when you use the AI directly, but far fewer when you use their API. 😅

Once you have a voice clone and a video, there are tools like sync.so that sync a given voice audio with video footage. It does a decent job.

But speaking of open source—cloning a voice is actually really easy now.

Jeff Geerling did a video about how scary the new Qwen3-TTS (text-to-speech) model is. No long speech sample needed—just a small voice extract and you get really good results. Sure, intonation and emotion still need work. But if you want to change a few words in a given speech? Really easy.

Try it yourself on Hugging Face: https://huggingface.co/spaces/Qwen/Qwen3-TTS

All in all, just chaining a few tools with some open-source models can get you surprisingly far in a matter of minutes—at okayish quality. It’s only a matter of time before the results become unrecognizable from real footage. 😬

📚What I Read/Watched

• ElevenLabs just got nuked by open source — Jeff Geerling shares his story about people faking his voice and the evolution of these open-source models

• Inside OpenAI’s in-house data agent — this will be the playbook for companies building data agents to lower the technical barrier for internal analytics

• GitHub just announced Claude & Codex available as coding agents

• Maxime Beauchemin (creator of Airflow) on the semantic layer’s role in the context of AI

• AI Expert: Here Is What The World Looks Like In 2 Years! — ex-Google insider Tristan Harris shares some nuggets about the AI race and its consequences for our economy and possibly democracy

I was in Amsterdam last week and my hotel had an American waffle maker?! First time I’ve seen this in the EU!!

With many people debating whether AGI is near—or even whether LLMs are truly intelligent—there’s an interesting paradox: will we stay intelligent while using them?

A French documentary (don’t worry, there’s auto-dub) called “La Fabrique à Idiots” (The Idiot Factory) explores the impact of AI in schools—how students use it for cheating and why it’s becoming nearly impossible to assign homework anymore.

My kid is 6, and it makes me think: how can I help him keep training his brain while still embracing the technology?

Someone online told me, “Well, LLMs are just compressed knowledge, like a book.” That feels like an understatement, as LLMs can go much further than simply delivering information.

And there’s science behind this. As mentioned in the documentary, learning requires three neural stages:

• Encoding: the hippocampus creates new connections

• Retrieval practice: the basal ganglia strengthen pathways through repeated recall

• Error correction: dopaminergic neurons fire prediction error signals that tell the brain what to reinforce or prune

When AI handles tasks for you, none of these mechanisms engage. We should watch out for ending up with an atrophied brain—and the choice is up to us.

🛠️ Obsidian and Claude Code

I’ve been playing with the Terminal community plugin for Obsidian to leverage more AI within Obsidian. Not necessarily for writing, but rather for linting and searching. Yes, Obsidian has good search mechanisms and Dataview (so the query I show in the screenshot is actually pretty basic). But I’m looking more for skills like “add a summary of this large note” or “fill in the missing metadata from the source URL.”

📚 What I read/watched

• Why paying DevRel matters: A reminder that DevRel is NOT an entry-level role. Yes, you can create marketing content as a junior, but true DevRel work requires deep technical knowledge and industry experience.

• Creator economy’s abundance crisis: Some good observations about how content abundance has surpassed demand (this applies to tech too) and how you can stay “authentic” when AI can generate so much content so easily.

• OpenAI went ALL IN on this Rust framework: Fun to see that TUI in Rust is so hot right now, given all the AI hype.

• Clawdbot is a security nightmare: Clawdbot (now renamed “Moltbot“), an open-source framework for running your personal AI assistant, gained more than 50k stars in just a few weeks. But as with many new open-source projects gaining quick traction, there are often security holes—so be careful!

• MCP vs Agent Skills: Kaxil (from Astronomer.io) explains the main differences between both in this thread. Will steal and reuse!

Most important AI note from one of my latest meetings. Yes, I’m lucky I can get decent sleep already.

I recently received this question on socials:

“Given what’s possible with AI, do you think it’s important for data engineers to branch into software engineering too?”

Honestly, if you’d asked me this two years ago, I would’ve said no. A key thing in my career has been to niche down (data engineer → devrel in data engineering). But I’ve been building way more stuff outside of data engineering these past months.

So what’s the model can’t replicate? I think deep niche understanding about the business and domain expertise still matters—but the execution layer is getting commoditized. The question isn’t “should I learn React?” anymore. It’s “do I understand the problem well enough to direct an AI to build the right thing?”

🛠️ Cursor’s plan mode

I don’t know how I missed it, but back in October 2025, Cursor released its plan mode.

It enables the model to research your codebase to find relevant files, review docs, and ask clarifying questions before writing any code.

This is basically what I used to do manually (and it still works if you aren’t using Cursor’s plan mode). Whenever I’d start a new project where I wasn’t sure about the architecture, UX, or technical implementation, I’d use a prompt like this while pinning relevant docs I’d previously indexed within Cursor settings:

Don't start any coding implementation yet. I'm thinking about X—ask clarifying questions and use @docs to verify what's possible.

Now plan mode does roughly that, and the UX within Cursor is nice since I can easily edit the plan and give the green light to build.

📚 What I read/watched

• AI’s trillion-dollar opportunity: Context graphs: Foundation Capital (VC firm from the Bay Area) discusses how the advantage in industry at the macro level is shifting from “systems of record” to where decisions are actually being made. Agents won’t replace systems of record, but the key missing piece is decision traces—recorded exceptions, approvals, and precedents—so agents can show why decisions were made.

• Can a VFX Artist Beat AI?: Zach King, the “magician of the internet,” made a fun video that reminded me you can still be really creative with AI rather than letting it beat you.

• The Thinking Game: A nice documentary about DeepMind (acquired by Google) and the breakthrough that would eventually win a Nobel Prize.

• The Big Constraint Flip: I know I talked about this in my last issue, but here’s another signal that resonates with me: we just passed a flipping point.

OK, I don’t know how I missed that UFO, but Raye’s live performance of “Where Is My Husband” is absolutely INSANE. EVERY live version. Such musicians, such a performance.

I’ve been playing with AI since 2024. I remember trying out Cursor for the first time and being mind-blown by how good it was... but it was actually BAD in absolute terms. It could only edit one file, and code quality was meh.

In 2026, we reached a tipping point where AI is so good—especially at coding—that you can’t ignore it in your work anymore.

I’ve always experimented with AI and different workflows, mostly around prompts and some limited MCP services. In 2026, I need to master more of these workflows.

Specifically, I’m interested in diving deeper into:

• GitHub spec kit

• Claude skills

• Building various MCPs for my daily work

• Working with multiple sub-agents and pushing work async as a reviewer

• How to manage memory for AI

Some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it, while the resulting magnitude 9 earthquake is rocking the profession. Roll up your sleeves to not fall behind. - Andrej Karpathy

🛠️ More voice, less typing

I’ve been experimenting with voice recording tools, specifically for:

• Meetings where I’m not in control of recording notes

• Meetings where I don’t want to send the AI summary

• For myself—spending more time speaking than writing

• Not having a big red button “Recording in progress”

I think the exercise of writing is still important, of course, but there’s something nice about speaking freely and getting a summary or reordering of your thoughts.

I stumbled on two nice open-source products: meetly and hyprnote.

I went with Hyprnote because it’s just markdown (yeah!) and I love their philosophy on not wanting to compete with tools like Obsidian, as described in their latest blog post “Filesystem is the cortex”.

I’m still figuring out my workflows, but all in all, it’s working pretty nicely!

📚 What I read/watched

• Welcome to Gas Town: A rather crazy take on how to run multiple agents with tmux. Note that I’ve seen more people managing agents through tmux lately.

• Full Course: The AI Stack We Actually Use for Prototyping, Strategy, and Personal OS (2026): Another example that there’s no manual for the best workflows—you need to figure it out. Good examples here using text files and markdown.

• Defense comes to software: Tomasz mentions that a lot of companies are restricting their APIs to own the full stack due to the rise of AI.

• Data Engineers are going to be whatever they want to be : Good take from on how the role of data engineer is shifting into multiple subroles given the rise of AI.

Last saturday was my last day of skiing with full powder before going back to work after my parental leave!

🧠 Will AI kill Python?

The GitHub Octoverse results are out, and TypeScript (TS) is now the most used language.
For context, on GitHub Octoverse 2024, Python dethroned JavaScript as the most used language across all work. There is no doubt that today, Python is still the undisputed king of AI and Data.
But here’s the irony: I’m a Python guy, yet I’ve been writing more JS/TS than ever.
I’m vibecoding apps with background jobs, and most of them rely on APIs, so TS fits perfectly this use case.

Why is TS gaining traction? TypeScript provides a much safer feedback loop for AI generation. Because LLMs can hallucinate APIs or import non-existent methods, TypeScript’s static typing acts as immediate “guardrails.” The AI (and the compiler) detects errors at the linting stage, not at runtime. It essentially allows the AI to self-correct before you even run the code.

Tools like Lovable and Replit that enable you to build apps with AI are targeting the web, so naturally, it’s all JS/TS. You can see why usage is exploding. That being said, Wasm might eventually shift the balance, but today, if I want to write for the web, it’s TS/JS.

🛠️ Holiday laptop cleaning with dua

Here we go again. My laptop drive is full, I have urgent things to do, and I need to quickly delete large files I don’t need (or worse, hidden cache).

I’m a macOS user (though dua is multi-platform), and I used to rely on an OG app called Disk Space Utility. The downside? The indexing was slow. While it gave a good map, I missed the speed of the terminal.
dua is an open-source fast terminal tool to view disk and manage disk space, written in Rust; you can navigate through big files in the terminal, mark them, and delete everything via keyboard commands.

I usually just go through the root / folder of my mac and launch dua i

Quick dua Cheat Sheet:

• dua i: Launch interactive mode.

• j/k : Up/down the current directory list

• h/l: Exit/enter a folder

• Space: Mark/Unmark the entry under the cursor.

• Ctrl + r: Remove all marked entries (careful!).

• Ctrl + t: Put the marked entries to the trash bin.

• ?: Show all keyboard shortcuts.

🧠 Seniors are great with AI coding; Juniors are hurting themselves

Because juniors can vibecode their way through problems with AI, they are skipping the basics. They skip the fundamentals. They get quick results now at the cost of long-term skills—specifically, the technical fundamentals required for critical thinking.

I watched a great video from Lee Robinson (DevRel at Cursor) about the future of AI coding, and one comment struck me:

“To young engineers, don’t skip learning the basics.”

raised a similar alarm in his recent blog:

“I fear we’re building a competency debt bubble. Just as we accrue technical debt by cutting corners in code and systems, we are now accruing human debt.”

🛠️ AI did my personal finance for 2026

OK, so I went wild. I know I could use local open models with Ollama for privacy reasons, but I was lazy and decided to give Gemini/Claude a go with some static CSV exports of my bank transactions.

My biggest challenge is always figuring out categories and getting the “bigger picture” view. There are tons of tools to manage budgets, but I wondered how far I could get with just two CSVs and a good prompt.

The two main challenges I faced:

1. The devil is in the details: I had to set specific conditions and ask the AI to flag “unknown transactions” for me to comment on. It was a “human-in-the-loop” workflow, but with no UI—just Markdown. It gave me a list with a column where I can add comment on larger miscellaneous transactions

2. Weird numbers: Of course, it initially hallucinated some recurring subscriptions, assuming I had them running for the full year when I didn’t. Also other stuff that didn’t add up. It looks at some transactions then quickly do some assumptions.

   I asked it to back up all data with actual sums using SQL and the DuckDB MCP server. It ran about ~30 queries locally to double-check its own math against the CSVs.

Honestly, it’s crazy how far you can get with such a minimal local setup.

📚 What I read/watched

• The future of coding: Idan Gazit breaks down Octoverse 2025 : A good breakdown of which language is being used for what, all in the context of AI. Great takes for the future.

• Dawn of the Brain-Rotted Zombies : Joe Reis raising the alarm on how we should teach (and learn) in the age of AI.

• AI codes better than me. Now what? : shared his experience coding with AI over the past year. He pushed a lot of projects he never would have been able to finish otherwise.

• Will AI replace human thinking? : Another blog from on the same theme as above, but with much more depth, evidence, and data.

• Critical n8n Flaw (CVSS 9.9) : Another week, another vulnerability exposed. This time, arbitrary code execution on n8n.

• SSDs Have Become Ridiculously Fast, Except in the Cloud : An older blog (Feb 2024), but I think the take is still valid. Especially NVMe cards are crazy fast and are still lapping what is available in the cloud. It’s a good reminder to keep some hardware local.

My 6-year-old riding into 2026. Earlier this week, we went through a scary ER visit (not ski-related). First time for me—terrifying. But as you can see, he’s all good now and ready to take on 2026.

Honestly, the only thing I wish for you this year is health.

🧠 Breaking down language barriers for education

Translation features have been around for a while. It’s pretty standard to see them implemented across different social platforms, letting you translate a comment, a Reddit thread, or an entire web page. However, what has changed recently is that some of these websites are now translating automatically, making content searchable across languages.

For instance, Reddit has been rolling out automatic translation features causing quite a stir around mid-2024. This leads to users replying in their native language without realizing the original post was auto-translated, resulting in awkward interactions where people have to clarify, “Hey, we’re speaking English here.”

YouTube is also pushing heavily in this direction. They have been rolling out features to automatically translate video titles and descriptions, making them searchable in other languages. Furthermore, YouTube officially launched multi-language audio tracks, and in September 2025 with an AI-powered dubbing service.

This trend likely kicked off with MrBeast, who originally created multiple localized channels and dubbed them manually. He realized that if he wanted to be the biggest YouTuber in the world, he had to capture the giant markets that don’t speak English.

While AI auto-dubbing can still sound a bit rough, I noticed a few people from Brazil following MotherDuck/DuckDB content using the Portuguese auto-dubbing. So, even for technical videos, it seems to be working!

Alec from ElevenLabs recently shared that creators got significantly more views when using their service to upload higher-quality dubs. The beauty of this is that you can easily clone your own voice with ElevenLabs. So it could be Auto dubbed with YOUR voice.

I think it’s great; we are tearing down barriers to amazing content that used to be language-specific. The only weird part is that we are evolving to view the world through an artificial layer that translates everything for us.

🛠️ “Serverless” RAG from Gemini

A couple of weeks back, Google released their “serverless RAG” through Gemini File Search. In short, instead of having to chunk and embed data yourself and manage a vector database, they do most of the heavy lifting for you. You just upload a file and start querying it. Nice, right?

I’m a big fan of Gemini’s API (at the moment—meaning this past week, because god knows what AI model is going to be top-tier next week), so I gave it a go. There are basically 3 API calls: create a store, upload a file, and query it.

In Python, per their documentation, it looks like this:

from google import genai
from google.genai import types
import time

# create client
client = genai.Client()

# File name will be visible in citations
file_search_store = client.file_search_stores.create(config={'display_name': 'your-fileSearchStore-name'})

operation = client.file_search_stores.upload_to_file_search_store(
  file='sample.txt',
  file_search_store_name=file_search_store.name,
  config={
      'display_name' : 'display-file-name',
  }
)

while not operation.done:
    time.sleep(5)
    operation = client.operations.get(operation)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="""Can you tell me about [insert question]""",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(
                file_search=types.FileSearch(
                    file_search_store_names=[file_search_store.name]
                )
            )
        ]
    )
)

I tried this on a couple of large PDFs, and one big issue is that you can’t easily update or delete existing documents/embeddings. If you have static information, that’s fine, but otherwise, it’s a major blocker.

Another thought is that because the context windows of the latest models are so large, I feel that a lot of use cases actually don’t need RAG anymore. Sometimes you want the whole corpus of a document in context, and it might not be smart to chunk it (e.g., “Give me the source blog of...”).

Other than that, it’s pretty cheap, so it’s worth trying!

📚 What I read/watched

• The RAM Shortage Comes for Us All: RAM prices are going up. AI datacenters being built are the culprit, and it seems the consumer line is getting hit. Manufacturers have a choice, but isn’t this a consequence of so much hardware being bought but not yet deployed for the AI giga-centers?

• Column Storage for the AI Era: A really good overview on the state of Parquet (vs. other file formats) from the creator of Parquet. It discusses what’s missing in Parquet today for the AI era, noting that the hardest part isn’t the file format itself, but getting the community and ecosystem to agree on specifications.

• Building an answering machine: Of course I’m biased as I work at MotherDuck, but with LLMs getting better, it feels like we are finally getting somewhere with “chat with your database” for analytics. Check the blog above for some neat examples.

• Project managers will be the new developers: WebDev Cody demoed his new project, Automaker. I should definitely experiment with tools where you just input a task, branch it out as an agent, and then review the PR.

• GitHub Actions Pricing Update: GitHub Actions is probably in my top 5 favorite cloud tools, so I’m really sad to see this nonsensical pricing: paying per minute on self-hosted GHA!? I don’t mind paying for the service, but that pricing model seems unfair.

I’m on parental leave. No, it’s not a playground. Yes, the MotherDuck AMS office has a swing AND a slide.

🧠 Are chat interfaces replacing traditional UIs?

What if we used less UI and more code going forward? What if, instead of clicking through interfaces, you had a simple chat that handled all the interactions for you?

Lee Robinson (DevRel at Cursor, previously at Vercel) shared his experience of removing the entire CMS from the Cursor website. A CMS is another layer of interface and complexity. In the age of AI-assisted development, it’s much easier to work with raw code so AI can easily modify things without navigating through additional layers.

So, chat everywhere?

Not quite. Lee’s example shows we could certainly remove some layers, but he also mentioned still wanting a basic GUI to manage assets, for instance. For website content management, you could definitely survive with minimalist features.

However, many workflows will still need specific, opinionated UIs. A chatbot won’t always cut it.

A good example is video editing. Sure, you could use a chatbot to remove all the “silence” from a video. But what the editor actually wants is the ability to easily adjust the silence threshold and—most importantly—preview changes so they can always roll back (or cut more). This requires tight integration with a classic video timeline and other controls.

A chatbot won’t provide an efficient workflow here.

🛠 OrbStack: A better container solution for macOS?

It’s weird this project didn’t fall onto my radar earlier.

OrbStack, per their definition, is “the fast, light, and simple way to run containers and Linux machines. OrbStack offers excellent performance and seamless integration with macOS.”

There are lots of alternatives to Docker Desktop. In the past, I’ve tried (in order of age/maturity) Rancher Desktop, Podman, and recently Apple’s own container runtime, simply called “Container” (yes, they missed the “iContainer” branding opportunity).

All of them were nice, but sometimes felt clunky and, most importantly, didn’t always have good support for devcontainers, which is how I use containers locally every day for all development purposes.

Docker Desktop may feel heavier and slower, but its support is generally solid.

I decided to give OrbStack a spin with a devcontainer (one container) running a Node.js app.

So yes, OrbStack has a significantly smaller footprint and includes nice features around mounted volumes and SSH to containers that I haven’t explored much yet.

That said, it’s closed source (like Docker Desktop) and backed by a much younger company.

I’ll continue using it as my default for the coming months and will report back.

📚 What I read/watched

• Reducing BigQuery Costs: How We Fixed A $1 Million Query - Shopify’s experience with a single query that would have cost nearly $1M. Old blog post, but a good reminder that small optimizations at scale can yield massive savings.

• this is the worst case scenario - Low Level shows pragmatically how bad the critical vulnerability affecting both React and Next.js is (CVE-2025-55182). If you have any React or Next.js projects, patch them now!

• The End of Coding Tutorials for Tech Creators? - Francesco Ciulla and Maximilian Schwarzmüller, two creators with solid experience making successful coding tutorials, discuss the trend toward “tech entertainment” over deep-dive coding tutorials. IMO we’ll need both in the future and there are too much of “tech entertainment” videos at the moment.

• Donating the Model Context Protocol and establishing the Agentic AI Foundation - Anthropic announced they’re donating MCP to the Linux Foundation. This could be a double-edged sword—only time will tell. But it’s probably a win for AI consumers if it leads to broader adoption beyond just Anthropic.

• Context Engineering the @mistercrunch Way - Maxime Beauchemin (creator of Airflow) shares his insights on organizing rules for LLMs without bloating your AGENTS.md and CLAUDE.md files. Useful patterns similar to what I have right now.

As I moved back to my hometown after 6 years, I opened some very old boxes and found my old consoles. After 20+ years, my save file was still there! The game is at 95% completion, and I have a sudden urge to finish it at 100% but I can’t remember anything from back then lol.

Can you guess which game it is, retro lovers?

🧠 Is AI resource usage killing the planet?

I recently stumbled upon a good essay arguing from that ChatGPT is not bad for the environment. Then, I read a jarring counter-perspective from claiming that a single Sora AI video burns 1 kWh. Meanwhile, we see massive investments in new infrastructure, like Anthropic’s $50 billion project.

So, are we killing the planet or not? The truth lies in the details.

First, we need to distinguish what “AI cost” actually means. While data on this has historically been imprecise, Google’s August 2025 report finally gives us solid numbers.

• Text is cheap: A query costs about 0.24 Wh : roughly equivalent to 9 seconds of watching TV.

• Video is expensive: Generating video is exponentially more energy-intensive. While tools like Kling 2.6 offer utility for artists, the energy cost of flooding the internet with “fun” Sora-style clips is massive compared to text.

Second, we must differentiate Training vs. Inference.

• Training is like building a stadium. Massive energy goes into the construction, but that cost is “fixed” regardless of whether 1 person or 10,000 people sit in it. This is the scary part: we are currently making a massive energy bet : burning resources now to build these “stadiums” and hoping that AI will improve life enough to justify the cost.

• Inference is the daily usage (the ticket to the stadium).

Finally, there is a surprising trade-off between Cloud vs. Local inference. Technically, the cloud is much better at “math-per-watt” due to specialized cooling and efficient hardware.

Your laptop is less efficient at the math, but it represents “sunk carbon”. The environmental cost to manufacture your phone or laptop has already been paid. Using the “idle compute” we already own locally might be the smarter move to avoid building endless new data centers.

The future will likely need to be a hybrid of both.

🛠 Tunnels: exposing localhost to the world

I recently needed a quick tunneling service to test a few things locally. Specifically, I had a webhook I needed to register to verify that my app could receive it and trigger the correct actions.

To do this, you typically need to register a public URL. This is where tunneling comes in: it makes your local machine (aka localhost:3000) available to the internet via a secure public link.

I used to use ngrok, but it has become increasingly restrictive for free usage (bandwidth limits, no static domains without paying).

After checking awesome-tunneling, I found Cloudflare Tunnel (cloudflared). It is incredibly simple to start and arguably the best free alternative right now.

In a setup with AI tools like Lovable or Replit, this is becoming less critical because they often provide their own cloud previews out of the box. However, if you want a true local development environment, a tunnel is still essential.

I suspected Cursor might eventually host apps for development purpose too.

📚 What I read / watched

• Driving Xiaomi’s Electric Car: Are we Cooked?: It’s great to see more competition in the EV space. Xiaomi (yes, the one that makes phones and tablets) seems to have really nailed it with this model.

• Anthropic acquires Bun: Anthropic acquiring an OSS JS runtime is... interesting. I’m curious to see the future of this, but to me, it proves that we still need good engineers. Generating code might be becoming a commodity, but engineering? That isn’t going anywhere. Otherwise, they would have just forked the project.

• Why Replicate is joining Cloudflare: Replicate (think Vercel, but for AI model hosting) has been acquired. Cloudflare continues to build a really neat catalog of products, but I feel the one thing they are missing is strong developer branding. I see AWS, GCP, and Vercel champions everywhere. Cloudflare? Not so much.

Two months ago, I challenged myself to make the best Sunday morning pancakes for my family. Given that my cooking skills hover around zero, this was ambitious, but I’m finally getting somewhere! 🧑‍🍳

🧠 Open Source projects are becoming less convincing

The business models and sustainability of open source have always been challenging.

In the past, if you wanted to push something into the open for others to use and contribute to, the bar was incredibly high. You basically had to sacrifice your evenings and weekends just to write the code. That effort was a signal: it showed a genuine commitment to, at the very least, maintain and move the project forward.

Now, with AI, anyone can spin up an open source project in a few minutes, throwing together code they’ve likely never reviewed. As a result, the commitment to maintainability has plummeted.

So, I’m looking at new open source projects with much more skepticism now—unless they are actually backed by a company.

There are still great new OSS projects, like Ghostty or Omarchy, but these are exceptions led by people who don’t need the money.

🛠 Modern orchestration for LLM workflows

As a data engineer, I’m familiar with orchestrators like Airflow, Dagster, and Kestra. These are designed for data dependencies and heavy batch compute. They are primarily declarative DAGs: “here’s the whole pipeline, go run it.”

Designing LLM workflows (or agents) requires a different approach. I need dynamic execution rather than raw compute power, as the system is mostly waiting for API responses. This is where event-driven, state-machine-style orchestrators shine.

I’ve been testing trigger.dev, a lightweight serverless tool where you define tasks directly within your code. You define task within your API, and the service will call these endpoint following a specific workflow and given you clear observability. It’s nice because your orchestrations is “built-in” within your app. There’s just another service calling endpoints.

An honorable mention goes to Inngest, while Temporal offers a heavier enterprise alternative.

I’ll share a deep dive soon on these once I’ve gathered more experience.

📚 What I read / watched

• 650GB of Data (Delta Lake on S3): Polars vs DuckDB vs Daft vs Spark: takes a “no tuning” approach, acknowledging that most devs don’t read the docs anyway. A pragmatic showdown of processing 650GB using different compute engines.

• What if you don’t need MCP at all?: An interesting take suggesting we don’t always need MCP. Often, simply letting LLMs run bash scripts is enough.

• Knowledge Management in the Digital Age: A hands-on look at ‘s “second brain.” He’s used Obsidian for years, so despite the length, there are great nuggets here for your workflow.

• My biggest programming regret: A reminder to build what excites you, not just what pays. If you are passionate and get good at it, the career and money will follow naturally.

We are constantly bombarded with online success stories and “the grind.” Here’s a photo of my new daughter to remind you that success is worthless if you can’t share it with real people.

Take time with your family and friends. Life is short.

🧠 The LLM paradox: preserving critical thinking

This has been on my mind for months. With LLMs at our fingertips, we risk becoming lazy thinkers. We ask a question, get the answer, and copy-paste...often without understanding the “how” or engaging our own brains first. It feels like our short and long-term memory is taking a hit.

Do you actually remember most of the answers you get from LLMs?

That said, AI is a powerful learning tool. Harvard has an internal AI chat for their CS50 students. It used to just “quack” (seriously, based on rubber duck debugging technique), but now it speaks English with what they call “pedagogical guardrails.”

Instead of just giving answers, it nudges students to think critically, ask questions, and work their way toward the solution.

Anthropic also announced Claude for Education back in April 2025 (aka “learning mode”). It’s not publicly available yet, but I suspect it follows the same Socratic approach.

I tried Gemini’s “Guided learning” announced in August 2025, but I was a bit disappointed.

I asked, “Can you explain to me what Apache Kafka is and how it works?” It jumped straight into a technical answer without assessing my background or the level of depth I wanted. While it did eventually ask a follow-up , eg : “What part of the Kafka system would you like to explore next?”.

I feel there is definitely space to improve how AI scaffolds learning rather than just retrieving facts.

Subscribe now

🛠 Vortex: file format rethought for our era

Parquet is legendary, but it was built for a different hardware era : spinning disks, HDFS, and large sequential scans. Today, we read data from fast NVMe and S3, mixing analytics with ML workloads that require quick, selective access.

Vortex rethinks the layout for this modern environment: it aligns directly with Arrow’s in-memory format, ditches Parquet’s heavy row-group structure, and uses flexible encodings. The result is 10–20× faster table scans and up to 100× faster random access, without sacrificing compression. For data engineers building retrieval-heavy systems, Vortex reduces I/O and CPU overhead while keeping the familiar columnar model.

For any new standard, adoption is key. Vortex already supports: Arrow, DataFusion, DuckDB, Spark, Pandas, Polars, and Apache Iceberg is coming soon (!).

It was recently added as a core extension in DuckDB, so I gave it a spin against a ~1GB Parquet file. The results were mixed: Vortex was faster, but not crazy faster, and the file size was only 3% smaller. I need to do more rigorous testing, but it looks promising!

📚 What I Read / Watched

• Agent Design Is Still Hard: Armin Ronacher (creator of Flask) shares gems on building agents with pragmatic takeaways. A must-read if you are building an agent!

• Librepods: Someone reverse-engineered Apple’s protocol to unlock all AirPod features on Android. Note: you need a rooted phone unless you are on Oppo/OnePlus.

• Post-mortem of Cloudflare’s outage: The “Internet was down” again thanks to Cloudflare. Hats off to them for the detailed post-mortem so quickly. The root cause was a change to ClickHouse permissions that made a metadata query return duplicates, generating a bad config file. Insane how small issues can escalate to the world’s eye.

• Fixing standup the only way I know how: Dreams of Code tries to automate stand-ups using n8n. TBH, might be over-engineered, but definitely an interesting attempt to solve the “problem” of the standup. Comments are interesting too.

I was speaking at the Forward Data conference today in Paris and the vibe was great!
Here’s me spreading the Ducklife (made with duckify.ai)

Hey there, I’m starting a new habit that I hope to stick with and that will help you: ctrl+r : a weekly recall from the terminal of my mind.
Each issue includes:

• 🧠 something I’ve been thinking about

• 🛠 something I’ve built, tried, or found useful

• 📚 something I read or watched, with my take

No fluff. Just highlights from my dev brain across data, AI, tools, and indie building.

🧠 Toon vs JSON

Last week, the TypeScript SDK for TOON hit 1.0 : a compact, token-efficient alternative to JSON designed for LLM prompts.
In short, instead of passing data to your LLM API through JSON like this:

{
  “users”: [
    { “id”: 1, “name”: “Alice”, “role”: “admin” },
    { “id”: 2, “name”: “Bob”, “role”: “user” },
    { “id”: 3, “name”: “Charlie”, “role”: “admin” }
  ]
}

You would use Toon encoding like this:

users[3]{id,name,role}:
  1,Alice,admin
  2,Bob,user
  3,Charlie,admin

As you can see:

• JSON repeats keys (”id”, “name”, “role”) every row → more tokens, more cost.

• TOON declares keys once, then streams values row-by-row → significantly fewer tokens, especially for large arrays (10k+ rows).

It’s interesting to see that while Toon has been around for a month, the trigger for the hype was the 1.0 release of the TypeScript SDK. Indeed, most LLM API calls today are made through TypeScript. Meanwhile, the Python SDK is still very early and under heavy development, so Python-heavy data pipelines aren’t adopting it yet.

🛠 Multi-LLM CLI

Like many of us, I’ve been juggling between LLM tools (be it UIs or CLIs like Claude Code or Gemini CLI), and it always presents the same challenges: finding past chats and having a common repository for prompts instead of framework-specific ones.
I’ve looked at multiple projects, and aichat comes closest to what I need. It’s missing a built-in TUI (I opened an issue here and prototyped one) to easily search for past conversations, but it has a decent REPL, and I’m already using it for some workflows.

# proofreader is prompt+model definition, here fixing grammar and lightweight edit
aichat --role %proofreader% “here’s my sentence that could use some grammar edits”

You can then, of course, wrap it up in a bash alias command or even a Raycast keybinding so you just write and get the result back.
Other projects worth mentioning I checked:

• Opencode

• llm by Simon Willison

📚 What I Read / Watched

• TUIs Are Perfect for LLM Chat Code to the Moon built shore for the same problem I faced and explained above. Aside from the project itself, he made really good points, and his channel consistently produces high-quality software videos (especially if you like Rust!).

• 90-percent Armin Ronacher (creator of Flask and popular developer in the OSS world) shares his experience with coding assistants, their strengths, and where they fail. Great insights from a truly experienced developer!

• Python 3.14 will change the way you parallelise code There’s a lot of noise about 3.14 and free threading that could significantly speed up Python for some tasks. However, as the author said: “I don’t think data pipelines will benefit from no-GIL though. Most don’t have latency requirements (rather throughput), and we already offload the bulk of CPU work.”

• How Not to Partition Data in S3 (And What to Do Instead) Interesting points highlighting that it’s generally more efficient to use datetime for partitioning large datasets on S3 (e.g., my_path/dt=2026-11-01=events.parquet) versus the common knowledge around Hive partitioning (my_path/year=2026/month=11/day=01).

• Gemini released their fully managed RAG service also known as the “File Search Tool.” This represents a next level of abstraction, making it interesting not to have to manage vector databases and other components. It will probably be useful for many use cases, as it’s often overkill to set up such infrastructure for the value it provides.

Hope you all had a great week. I’m still figuring out what to program for my new NuPhy Air75 V3 keyboard keycaps... any suggestions???

The MCP ecosystem is exploding —there are far more MCPs than actual users. We're drowning in noise. How do you figure out which MCP deserves your attention?

mcp.so lists 16,024 MCPs as of today 😱. Some are weekend hackathon projects, others are official implementations backed by companies pushing their product's MCP integration.

There are also countless duplicates cluttering the space.

Most of them are useless. Most of them will die.

As a reminder, MCP (Model Context Protocol) is Anthropic's open standard that lets AI assistants securely connect to external data sources and tools. Think of it as a bridge between your AI chat and the real world—databases, APIs, file systems, and more. Instead of manually feeding information back and forth, MCPs let your AI assistant directly interact with these systems.

What makes an MCP worth your time?

Here's a simple test: look at what you're copy-pasting into your AI chat. If the AI could make decisions automatically and eliminate that copy-paste step, you've probably found a use case worth building an MCP for.

Web development's copy-paste problem

Web development has two major pain points that create endless copy-paste cycles:

Runtime debugging: Issues that only surface when you're running the local server. Your code compiles fine, but something breaks at runtime. You find yourself constantly copying error messages from the console, network request failures, and stack traces into your AI chat.

UI iteration hell: Describing visual changes is inherently difficult. "Make this button there next to x" doesn't translate well to precise CSS modifications. You end up taking screenshots, uploading them to your AI assistant, describing what's wrong, getting code suggestions, implementing changes, taking another screenshot, and repeating the cycle.

I sometimes create quick mockups in Figma as reference points, but I still end up in the screenshot → feedback → code → screenshot loop. It can be exhausting.

In fact, the core problem is rather simple : it's the friction between your development environment and your AI assistant. They exist in separate worlds, connected only by your manual copy-paste bridge.

Browser Tools MCP

browser-tools-mcp is one of the genuinely useful MCPs out there (5.8k stars and counting). It eliminates the copy-paste friction by giving your AI assistant direct access to your browser environment.

Here's what I've been using it for :

Console and network debugging: read console logs, inspect network requests, and analyze runtime errors. It sees the same error messages you do, but faster.

Visual debugging: It can take screenshots of your application and analyze the UI directly.

SEO analysis: flag on-page SEO issues, check meta tags, analyze page structure, and suggest improvements without you having to audit everything manually.

Setup

The browser tools MCP works by establishing a bridge between your browser and the MCP server. Here's how the architecture works:

The browser extension acts as a client that exposes browser APIs to the MCP server. When your AI assistant needs to interact with your webpage, it sends commands through the MCP protocol to the server, which then communicates with the browser extension.

This architecture is nice because it maintains security boundaries—the AI can't directly execute arbitrary JavaScript in your browser. Instead, it goes through the controlled MCP interface, which exposes only specific, safe operations.

Getting started requires a few components:

1. Browser extension: Install the browser tools extension and enable it. This creates the bridge between your browser and the MCP server.

2. Active browser tab: You need a running application to inspect. The extension works with any webpage, but it's most useful with your local development server.

3. MCP server: Install and run the server with npx @agentdeskai/browser-tools-mcp@latest. This handles the communication between Claude and your browser.

4. Server service: Run npx @agentdeskai/browser-tools-server@latest to start the service that manages browser interactions.

This setup process reveals something important about MCP adoption: it's still early days. The fact that you need to run multiple services and install browser extensions shows that MCPs aren't quite plug-and-play yet.

But for developers who deal with the copy-paste problem daily, the setup overhead is worth it.

After that, you can just prompt it to check whatever logs (or screenshots) are needed. More data and context means better code.

The bigger picture

Browser tools MCP represents what good MCP development looks like: solving a real, specific problem that developers face daily. It's not trying to be everything to everyone—it focuses on browser interaction.

The key is identifying those repetitive, mechanical tasks that create friction between you and your AI assistant. Every copy-paste operation is a potential MCP waiting to be built.

Yes, setup for MCP tools like this one is not easy, and there is plenty of room for improvement.

That being said, it saves me countless copy-paste cycles.

Here's to the next MCP that makes me less of a monkey worker 🥂

Apple just dropped something no one expected at WWDC (their annual developer conference) with the announcement of their own containerization framework for macOS.
And yes, everyone's asking the same question: is this the end of Docker Desktop and Podman on macOS? These are two popular alternatives that developers use to run local linux containers today.

Let's dive into what Apple has built, explore its features and current limitations, and get our hands dirty with some actual code examples.

If you prefer watching over reading :

Meet "Container" (yes, that's really the name)

I have to say, Apple's developers aren't quite as creative as their marketing team when it comes to naming. The project is simply called Container, though if you check their official announcement page, it's referred to as the "Containerization Framework."

The framework consists of two main repositories:

• Containerization: The core virtualization engine

• Container: The CLI tool that developers will use to create and manage lightweight VMs

One fun fact that caught my attention: I know for certain that Apple actually hand-wrote this code because a PR was submitted to fix typos in variable names and comments - something an AI agent will never do 😅

Kudos to Apple for the handcrafted code 👏

The new architecture: one Virtual Machine (VM) per container

The framework is built as an open-source Swift framework, released under the Apache 2.0 license. This is particularly interesting, considering Docker Desktop has not been free for commercial use for some time. If you’re using Docker Desktop at work, you probably owe Docker some money.

Docker Desktop is free for small businesses (fewer than 250 employees AND less than $10 million in annual revenue), personal use, education, and non-commercial open source projects.

The new architecture: one Virtual Machine (VM) per container

Here's where things get really interesting. A traditional container engine like Docker Desktop runs one large Linux virtual machine in the background, even when no containers are running. All your containers share this single VM, which can introduce security risks since files must pass through the shared virtual machine before reaching your container.

Apple's approach is fundamentally different: each container gets its own dedicated virtual machine. This provides:

• Strong security isolation

• Complete container separation

• Individual IP addresses for each container

That last point is nice - no more port forwarding headaches! You can access your local web services directly via the container's IP address.

Apple claims startup times are within seconds, which is pretty impressive for full VM isolation.

But let's confirm this and run the thing.

Installing Container on macOS

To install it, you can simply install the package installer file (.pkg) on their release notes page

Once done, you will first have to launch the service by :

container system start

If you are familiar with Docker for Desktop or Podman, you'll feel right at home as commands are pretty similar. And yes, it does support building from Dockerfile

$ container --help
OVERVIEW: A container platform for macOS

USAGE: container [--debug] <subcommand>

OPTIONS:
  --debug                 Enable debug output [environment: CONTAINER_DEBUG]
  --version               Show the version.
  -h, --help              Show help information.

CONTAINER SUBCOMMANDS:
  create                  Create a new container
  delete, rm              Delete one or more containers
  exec                    Run a new command in a running container
  inspect                 Display information about one or more containers
  kill                    Kill one or more running containers
  list, ls                List containers
  logs                    Fetch container stdio or boot logs
  run                     Run a container
  start                   Start a container
  stop                    Stop one or more running containers

IMAGE SUBCOMMANDS:
  build                   Build an image from a Dockerfile
  images, image, i        Manage images
  registry, r             Manage registry configurations

SYSTEM SUBCOMMANDS:
  builder                 Manage an image builder instance
  system, s               Manage system components

To pull an image, you would do :

container image pull python:3.12

And to run for instance a python shell within the above image :

container run -it python:3.12 python

Subscribe now

Current limitations

Before you get too excited, there are some important caveats. The framework is designed primarily for macOS 26 (the upcoming 2025 fall release, still in beta as the time of this writing), though it works on macOS 15 with limitations.

Yes, the version jump from macOS 15 to 26 is definitely confusing. Apple decided to align macOS version numbers with the current year. The transition might sound even more confusing at first, but it will make more sense over time—you’ll be able to tell which year the OS is from just by its version name!

Key limitations as of now on macOS 15 :

• Container-to-container networking isn't fully supported yet. This is a major limitation if you're running multi-container setups like a web server with a database.

• Container IP Address Management : there are still some rough edges around how container IP addresses are handled and accessed.

Performance comparison: Container vs Docker Desktop

I ran some quick tests comparing Container with Docker Desktop by running a simple Python shell through a python:3.12 image, and the results were interesting:

Surprisingly, pulling images was noticeably faster with Docker for Desktop compared to Container. I'm not entirely sure why, but one reason was probably because I had some layers already cached on the Docker local registry.

Looking at Activity Monitor:

Docker Desktop:

• Large shared VM consuming ~3.5GB RAM

• Multiple background processes

• Consistent CPU usage even when idle

  Apple Container:

• Smaller individual VM footprints ~ 200MB RAM per container

• Lower baseline resource usage

• More efficient per-container resource allocation

However, keep in mind that Docker’s shared VM model means the overhead is amortized across all containers. With Apple’s approach, each container incurs its own overhead—but in practice, this is usually still lower than the Docker Desktop engine, since most developers typically run only 2–3 containers at a time.

Exciting but early

Apple's containerization framework represents a great approach to linux container isolation on macOS. The performance benefits and security improvements are nice, especially the individual VM architecture and direct IP addressing.

However, it's still very early days. The missing multi-container networking, uncertain Docker Compose support, and devcontainer integration (for VSCode/Cursor) questions make it hard to recommend for use today.

That being said, I expect these feature gaps to be filled by the time macOS 26 reaches general availability—so let’s take it for another test drive in a few months!

Here's my prediction for the future : Medium-sized software companies are dying. And it won’t be because of market crashes, VC winter, or the next AI wave killing jobs (well, maybe a little).

They’ll die because, for the first time ever, they may become unnecessary.

When I say “software companies,” I mean exactly that: businesses built purely on software. No factories. No physical supply chain. No custom silicon or overseas production dependencies. You might still get an AWS bill that looks like a ransom note, but that’s about as “operational” as it gets.

Software is light. And in 2025, with all things serverless, cloud-native, and generous free tiers, it’s lighter than ever.

AI has dramatically reduced the cost of shipping features and building MVPs. But I think the really wild shift isn’t in cost — it’s in team size.

Medium-sized companies are in the worst spot. Startups are nimble. Giants have capital and reach. But the ones in the middle? Too big to stay scrappy, too small to compete on scale.

Let’s unpack that — and what it means for the future of software engineering if that prediction plays out.

Small teams, big power

Thanks to AI and improved automation, small teams are now playing in the big leagues. I actually know a few solo-preneurs and/or small teams landing enterprise clients.

Small teams aren’t just fast at building products. They’re close to their customers. They have ultra-tight feedback loops. They can tailor solutions with speed and precision — while larger orgs are still scheduling the kickoff meeting for the kickoff meeting.

Everyone who's worked at a fast-growing company knows that scaling is painful.

Hiring takes time. Onboarding takes longer. Context sharing gets messy. And suddenly, the scrappy startup that shipped a major feature every week is now bogged down in process, sync meetings, and permissions management.

If you've ever been frustrated at work just because of a missing permission or a ticket stuck in limbo… I feel you.

With fewer people, you ship faster. You stay closer to your users. You kill features (or even whole products) quickly without causing internal revolts. And you let AI fill in the gaps that used to require entire departments.

What if staying small is not only possible, but preferable?

A Better world for customers — and Engineers?

Now that we acknowledge the possibility of this shift, what happens when the market is full of these small-but-mighty teams?

From a customer’s perspective, it might feel like a golden age. More options. More competition. Faster updates. Closer support.

Yes, discovery could get overwhelming. But honestly, that's a solvable problem — and far better than the alternative of stale monopoly software. Think of how exciting the indie game scenes are compared to their corporate counterparts (if you are a gamer like me, you know). Software starts to feel alive again.

From a software engineer's perspective, it’s a little more nuanced.

If the trend holds, we’ll see more jobs — but in smaller companies. That means:

• You’ll probably wear more hats. And that’s not a bad thing.

• Job security in any one company could be lower — but you’ll gain experience faster, with more chances to work on different products throughout your career.

• You'll be closer to the business, with a tighter feedback loop.

You’ll learn about infrastructure, product decisions, customer feedback loops, and maybe even business models. You’ll feel the impact of what you build for real users.

This feels like a great opportunity for continuous learning. Sure, it won't be your cozy corporate job, but the growth opportunity will be endless.

Generalists first

If small companies become the new default, software engineers will need to think more like product builders — or even founders.

As in any small startup, you won’t just be writing code. You’ll be choosing tools, managing infrastructure, talking to users, prioritizing features and yes, sometimes answering support emails.

That means generalist skills are going to matter more: full-stack engineering, rapid prototyping, even basic design and copywriting.

Playing devil's advocate — there will still be a need for deep specialists.

There are plenty of domains where depth still wins. If you’re working on database systems, fintech, or medical software, you’ll need real expertise. AI can help with boilerplate, but it can’t replace judgment or domain knowledge.

For example, if you’re building a new payment platform, knowing how settlements work, how fraud detection operates, or how different regulatory environments interact is not something ChatGPT can fully solve for you. Especially in R&D, fundamentals matter.

The difference is that specialists may increasingly become contracted or embedded, rather than hired into an in-house team. Small companies will bring in that deep knowledge when they need it, not assume they need a full-time expert for every vertical.

What should you do now?

If you're a software engineer today, this shift opens up real opportunities — but also calls for a mindset change.

First, embrace AI tools to increase your productivity. My key takeaway with AI is that you shouldn’t delegate the entire process. Even “vibe coding” requires domain knowledge. Keep learning the fundamentals and stay curious about how things work. The boring implementation code? Sure, let AI handle that.

Second, don’t fear small companies. You’ll probably learn more in 6 months at a 5-person startup than you will in 2 years at a large corporation. Learn to wear multiple hats.

Finally, the good news is : you can prototype all of this by yourself, as a solo-preneur. The best way to learn is to get your hands dirty. My own side project right now is subtldr (yes, a small plug — but hey, you're getting this content for free, so I figured it's fair).

Maybe I’m overly optimistic. Or maybe we’re finally entering a more sustainable, more human phase of software?

Who knows, but let’s talk again in 2030.

A lot of software engineers use AI daily to write code, but how many are actually taking advantage of all the features available to them?

Sure, you can craft solid prompts and rely on your technical knowledge to navigate the output. But in today’s world of rapid innovation, some teams — like Cursor — are shipping features at lightning speed. Should you care about all of them? Probably not.

Could some of them drastically improve your workflow with AI? Definitely.

If your AI often writes outdated API code or you’re constantly living on the bleeding edge (because hey, things move fast), then this blog post is for you.

Why Cursor?

I’ve been using Cursor for almost a year now, after switching back and forth with VSCode. While VSCode is starting to adopt features from Cursor, such as agent mode, the implementation still lags. With recent layoffs, even if the VSCode team isn’t directly affected, I bet Cursor will continue to innovate at a faster pace, making it my preferred editor.

Docs context is king

Let’s look at what I believe are the two most underused Cursor features: documentation context and Cursor rules.

In Cursor, under Settings > Cursor Settings > Features > Docs, you can add documentation sources to be used as context in your prompts.

These sources are crawled and indexed. They can be:

• Documentation websites

• API docs

• Raw GitHub code (if open-source)

When you add a custom documentation URL, you give it a name (an alias for your prompts), and Cursor crawls and indexes it for you.

Once these are added, you can reference them in your prompt using @docs <my alias name>.

Now, there’s actually something faster than just adding the plain root URL of the documentation website.

Something that will make Cursor easier to crawl and index the documentation.

llms.txt

While robots.txt and sitemap.xml are designed for search engines, LLMstxt.org is a new standard optimized for LLMs. It provides site information in a format LLMs can easily parse.

It's an evolving standard, and many developer tool docs have started adopting it this past year as LLMs usage grew drastically. It solves a real problem: when AI scrapes raw HTML, it gets a lot of noise — navigation bars, JavaScript, CSS 🤢.

This is especially important now because we will soon (or already have) more LLMs reading the docs than humans. Andrej Karpathy highlighted this trend shift in his post.

llms.txt offers clean, structured information optimized for AI, making updates much faster than re-crawling entire websites.

The specification defines two files:

1. /llms.txt: A structured view of your documentation navigation (like a Markdown-based sitemap.xml)

2. /llms-full.txt: A single file containing all your documentation in one place

Quick example with Supabase documentation

A lot of documentation website may highlight the llms.txt link directly as a button, but in general, you can just try `awesometool.com/docs/llms.txt`, `docs.awesometool.com/llms.txt` or `myawesometool.com/llms.txt`

Supabase, interestingly, has different llms.txt files at `supabse.com/llms.txt` depending on the client API.

This shows that while there’s some standardization around llms.txt, the framework is still flexible and evolving.

In action with rules

Cursor rules live in .cursor/rules, and you can scope them using path patterns. Each rule is written in a .mdc file — a kind of supercharged Markdown designed for Cursor.

Unfortunately, as of today, you can’t reference @docs in rules — only static files in your repo as per discussion in the forum here.

You can find more Cursor rules at: https://cursor.directory/

I use Cursor rules to explain high-level setup and tech stack. Without them, the LLM might suggest alternatives instead of using what’s already in place. Cursor rules prevent that.

Example Cursor rule for my personal website:

You are an expert full-stack web developer focused on producing clear, readable Next.js code.

You always use the latest stable versions of Next.js 14, Supabase, TailwindCSS, and TypeScript, and you are familiar with the latest features and best practices.

Prompt Generation Rules:

- Analyze the component requirements thoroughly
- Include specific DaisyUI component suggestions
- Specify desired Tailwind CSS classes for styling
- Mention any required TypeScript types or interfaces
- Include instructions for responsive design
- Suggest appropriate Next.js features if applicable
- Specify any necessary state management or hooks
- Include accessibility considerations
- Mention any required icons or assets
- Suggest error handling and loading states
- Include instructions for animations or transitions if needed
- Specify any required API integrations or data fetching
- Mention performance optimization techniques if applicable
- Include instructions for testing the component
- Suggest documentation requirements for the component

General Component Creation Guidelines:

- Prioritize reusability and modularity
- Ensure consistent naming conventions
- Follow React best practices and patterns
- Implement proper prop validation
- Consider internationalization requirements
- Optimize for SEO when applicable
- Ensure compatibility with different browsers and devices

General Rules:

- Enable strict TypeScript (strict: true in tsconfig.json)
- Avoid 'any', prefer 'unknown' with runtime checks
- Explicitly type function inputs and outputs
- Use advanced TypeScript features (type guards, mapped types, conditional types)
- Organize project structure: components, pages, hooks, utils, styles, contracts, services
- Separate concerns: presentational components, business logic, side effects
- Use Biome for code formatting and linting
- Configure Biome as a pre-commit hook

Next.js Rules:

- Use dynamic routes with bracket notation ([id].tsx)
- Validate and sanitize route parameters
- Prefer flat, descriptive routes
- Use getServerSideProps for dynamic data, getStaticProps/getStaticPaths for static
- Implement Incremental Static Regeneration (ISR) where appropriate
- Use next/image for optimized images
- Configure image layout, priority, sizes, and srcSet attributes

TypeScript Rules:

- Enable all strict mode options in tsconfig.json
- Explicitly type all variables, parameters, and return values
- Use utility types, mapped types, and conditional types
- Prefer 'interface' for extendable object shapes
- Use 'type' for unions, intersections, and primitive compositions
- Document complex types with JSDoc
- Avoid ambiguous union types, use discriminated unions when necessary

TailwindCSS and shadcn/ui Rules:

- Use TailwindCSS utility classes for styling
- Avoid custom CSS unless absolutely necessary
- Maintain consistent order of utility classes
- Use Tailwind’s responsive variants for adaptive designs
- Leverage shadcn/ui components for rapid development
- Customize shadcn/ui components only when necessary
- Define and use design tokens in tailwind.config.js

You can go pretty far with multiple rules, but even a high-level overview of your tech stack will already help a lot. It stops the LLM from blindly guessing your stack or suggesting duplicate libraries.

With a combination of rules and @docs, your answers will improve significantly. Again: context is king.

LLMs are like pets — they need to be fed properly.

I’ve never been this productive on my Mac in the past two years. Sure, AI tools have helped a lot — but one of the key changes I made had nothing to do with AI. It’s much simpler than that.

I'm saving a ton of time just managing my laptop: opening new apps, switching tabs, or finding things is blazingly fast. It almost feels like mind control — but in reality, it's just a focused keyboard workflow. That’s the real key.

To do this, I use three open-source tools. In this blog, I’ll break down my setup step by step, how I use it, and why:

• Aerospace

• SketchyBar

• Raycast (bonus)

If you want a complete reference, you’ll find my full configuration in my dotfiles repository.

Level 0: Keyboard First

Let me repeat: I don’t think you can be truly productive as a developer (or any app-intensive user) if you rely too much on your mouse. The keyboard unlocks so many underrated possibilities.

We often underestimate how slow it is to click through UI elements.

Fun fact: Some banks and insurance companies still use old mainframe software where operators only use keyboards. I’ve worked on projects revamping those systems, and surprisingly, many operators were frustrated at being forced to use a mouse — even if the UI looked more modern and intuitive.

Here’s a simple test: if you’re right-handed, try using the mouse with your left hand for a few days. It’ll be so painful that you’ll naturally start figuring out faster ways to navigate — with the keyboard.

Once you get past the initial friction of memorizing keyboard shortcuts, you’ll never go back.

Level 1: Free Up Your Screen

So you’ve just booted up your Mac, and you see that ugly dock taking up precious screen space.

As developers, we spend most of our time in editors and browsers — every extra vertical pixel counts.

The first smart move? Shift the dock to the left and set it to auto-hide. Yes, it feels weird and empty at first. You might wonder: How do I switch apps now?

Level 2: App Shortcuts

There are multiple ways to handle app shortcuts — even built-in ones on macOS.

Aerospace, a tiling window manager, also supports assigning shortcuts to apps, all from a single config file.

To install Aerospace with Homebrew, you simply do :

brew install --cask nikitabobko/tap/aerospace

Once launched, you’ll find its icon in the menu bar.

The configuration file is located at: ~/.config/aerospace/aerospace.toml

To create an app shortcut, use exec-and-forget and map it to a keybinding:

alt-b = 'exec-and-forget open -a /Applications/Brave\ Browser.app'

I typically use the first letter of the app or context : alt+b (browser), alt+c (code) and alt+t (terminal)

Now you have a clean, keyboard-based app launcher — and more screen space. On to the next level: window management.

Level 3: Window Management

This is where a tiling window manager shines. It eliminates floating window chaos and allows for a structured, keyboard-driven layout.

What about Yabai ? I used Yabai for more than a year, and honestly, it integrates more natively but since macOs 15.2, SIP need to be disabled for some key features and it was a sad goodbye. If disabling SIP is not a blocker for you, I would recommend watching my video on Yabai setup. That being said, Aerospace now covers most of the same features.

To improve visual focus, I also recommend JankyBorders — a lightweight tool that highlights the currently focused window.

You can install it through Homebrew too, and the default configuration is already pretty fine.

brew tap FelixKratz/formulae
brew install borders

Now back to aerospace.toml. Here are some useful shortcuts for managing windows:

# toggle window zoom
alt-f = 'fullscreen'

# toggle window split type
alt-e = 'layout tiles horizontal vertical'

# focus window
alt-h = 'focus left'
alt-j = 'focus down'
alt-k = 'focus up'
alt-l = 'focus right'

For instance, whenever I open a new window on my browser - you'll see it going next nicely.
I can now easily switch focus on another window still using the keyboard. That's where having a visual cue, with janky boarders, of which window is being focused right now, helps.
You can also change the split or zoom temporarily on one window.

It starts to feel… blazingly fast.

Level 4: Workspaces

With smart workspace management, I barely need a second monitor. I use one 90% of the time.

macOS has a built-in Spaces feature, but there’s no clean API to control it. Yabai can hack into it, but again — SIP needs to be disabled. Instead, Aerospace introduces its own virtual workspaces.

Why use workspaces?

1. Dedicated apps on dedicated workspaces

2. Minimize clutter — aim for 1–2 apps per workspace

You can automate app-to-workspace assignment like so:

on-window-detected
if.app-id ='com.brave.Browser'
run = ['move-node-to-workspace 1']

Navigate or move windows between workspaces with:

alt-1 = 'workspace 1'
alt-2 = 'workspace 2'
alt-3 = 'workspace 3'
alt-4 = 'workspace 4'
alt-5 = 'workspace 5'
alt-6 = 'workspace 6'
alt-7 = 'workspace 7'

# See: https://nikitabobko.github.io/AeroSpace/commands#move-node-to-workspace
alt-shift-1 = 'move-node-to-workspace 1'
alt-shift-2 = 'move-node-to-workspace 2'
alt-shift-3 = 'move-node-to-workspace 3'
alt-shift-4 = 'move-node-to-workspace 4'
alt-shift-5 = 'move-node-to-workspace 5'
alt-shift-6 = 'move-node-to-workspace 6'
alt-shift-7 = 'move-node-to-workspace 7'

I usually assign 5 workspaces to my main screen and 2 to a secondary:

[workspace-to-monitor-force-assignment]
1 = 'main'                         
2 = 'main'                      
3 = 'main'                  
4 = 'main'                  
5 = 'main'
6 = 'secondary'
7 = 'secondary'

Now I can either go to a given workspace using alt+<number> or the app shortcut I put on initially if I want to join a specific app, so I don't have even to remember the space.

If I want to move an app to another screen, it’s as simple as moving it to a workspace assigned to that screen.

For example, to move an app from the main screen to the secondary screen:

1. Focus the app using its shortcut — for instance, alt+t for the terminal.

2. Move it to workspace 6 or 7 (which are mapped to the secondary screen) using alt+shift+6.

Now you might be wondering: “But Mehdi, how do you keep track of which apps are running in which workspace — especially if you’re constantly moving them around? Do you just memorize everything?”

That’s exactly where a custom status bar comes in.

If you want a deeper dive into Aerospace, check out my walkthrough video

Level 5: Custom Status Bar

Sketchybar replaces the default macOS menu bar with a customizable one — and frees up space.
Be honest: how often do you use the default menu bar? Once a week? That’s wasted space.

First, we'll autohide the macOs menu bar in System Settings > Control Center :

That means this one is still available if needed.

We'll use Sketchybar to display :

• Workspaces and applications running

• Focused windows

• System info (battery, Wi-Fi, sound)

Install SketchyBar:

brew tap FelixKratz/formulae  
brew install sketchybar

Start with someone else’s config — there are plenty of examples. My config is also available in my dotfiles.

The setup consists of:

• sketchybarrc (main config file)

• Plugins (Bash/Lua scripts)

Thanks to Sketchybar I know now which workspace my apps are, plus what is the current active app/workspace selected.

Level S: Special God Mode

That covers the full window management workflow: app shortcuts, workspace assignments, tiling layout, and a smart status bar.

One last tool I rely on a lot is Raycast. Think of it as a command palette on steroids.

With Raycast, I:

• Search files

• Insert emojis

• Launch specific git projects

• Pick colors from my palette

• And much more

Honestly, Raycast deserves its own blog post. If you’re a productivity nerd, let me know — I’d love to dive deeper.

In the meantime, take care of yourself — and your keyboard.