Kevin London

I've spent years contributing to open source projects, but it's been a long time since I built and shipped a complete piece of software solo. This Thanksgiving, I built voxtype, a push-to-talk voice transcription tool for Linux. macOS and Windows have had solid voice typing for years, and even Google Docs has it built in. But on Linux, especially on Wayland, the options are limited. Most solutions are cloud-based, X11-only, or tied to specific desktop environments. The few local options that exist are python-based. No shade to python, but requiring you to install pytorch, pytorchaudio, and a dozen other dependencies into a virtual environment, and remember to activate it every time you reboot is cumbersome. Vocalinux is pretty good but I got stuck in dependency hell trying to set it up, and I find it sluggish. I wanted something simpler. Install a package, download a model, enable a service, done. Voxtype is available from the AUR for Arch based systems, and as a .deb or .rpm package. Run a few commands post-install, enable the systemd user service and it just works every time you log in. No virtual environments, no dependency conflicts, no activation scripts (well, except systemd). Hold a hotkey, speak, release, and your words appear at the cursor. It uses Whisper locally through whisper.cpp, so everything stays on your machine. Voxtype makes no network requests and uses no cloud transcription services. The interesting technical challenge was making it work across all Wayland compositors. Since Wayland's security model blocks the usual approaches for global hotkeys and input simulation, voxtype works at the kernel level using evdev and uinput. This means it runs the same on Sway, Hyprland, or any other compositor. It's a little "omakase" in that it's meant for Hyprland or Sway with Waybar. That's where you'll have the best experience. But it works on any compositor, and doesn't require Waybar. It works great for me, which, to be candid, is enough for me. If you find it useful or have constructive/helpful feedback, that's a bonus.   It's MIT licensed: https://voxtype.io

41

11 Comments

I spent a Saturday with an AI coding assistant and shipped 5 games + a website. Here's what I learned. I lead engineering at Samsara - but on weekends I still like to write code with my own hands. Last Saturday I sat down with Claude Code and ran an experiment: how much of my 10-year side project backlog could I clear in a single day? The answer: 5 playable browser games and a fully rebuilt personal website. In about 12 hours. What got done: - Resurrected a personal site that had been running on an unmaintained CMS since 2014 - rebuilt it as a static Jekyll site, recovered blog posts from a MySQL database, and got decade-old Flash demos running again via WebAssembly - Ported 3 old game jam games from Haxe/OpenFL to Godot 4 with full HTML5 browser export - Built a brand new game from scratch 128 million tokens processed. ~126 prompts from me. ~4 hours of active AI compute. The AI handled the mechanical work — reading old codebases, extracting collision data, generating level layouts. I handled architecture, game design, and the "make it actually fun" part. What I took away as an engineering leader: 1. Front-load context. The projects where I gave the AI everything upfront shipped in one pass. The ones where I drip-fed information took 3x the iterations. This mirrors how we onboard engineers - the more context you give someone on day one, the faster they're productive. 2. Describe outcomes, not implementations. "Ghost collisions where the plane crashes but nothing is touching" produced better fixes than "shrink the hitbox by 10 pixels." Good problem statements matter more than prescriptive solutions - true for AI tools and for engineering teams. 3. State quality bars early. The AI defaults to the simplest working approach unless you tell it otherwise. So does every engineer under time pressure. Being explicit about "good enough" vs. "production quality" saves rework. 4. The bottleneck is knowing what you want. The tools are absurdly capable. The limiting factor is clear thinking about requirements, architecture, and design. That's an engineering leadership skill, not a coding skill. AI coding tools aren't replacing engineers. They're amplifying the ones who know what to build and why. The gap between "can write code" and "can ship products" just got wider. Full technical write-ups with code, architecture decisions, and playable browser games: https://lnkd.in/gpqnh5Zh  #engineering #ai #softwareengineering #leadership #samsara #gamedev

54

4 Comments

Recently I gave a talk at SF Ruby about a library we built (and recently open-sourced!) at AngelList called Zaxcel. Why'd we build it? Excel is the lingua franca of finance, but most programmatic Excel generation libraries force you to think in coordinates and formula strings. We took a different approach: model the workbook as a directed graph where data flows through named objects. Let the library handle coordinate resolution and formula composition. The result is a DSL that actually makes sense: you write formulas as Ruby expressions, reference things by name, and the type checker catches mistakes at compile time. It's revolutionized how we build financial statements. What used to take weeks now takes hours (and with AI agents - only minutes!), empowering thousands of workbook deliveries a quarter. Read how we went from nightmare refactors to 100x productivity: https://lnkd.in/es2aTttR Open-sourced repo (you can use it today!): https://lnkd.in/ecKRwcaW

91

8 Comments

I've successfully nerd-sniped myself into building a personal ai assistant running locally for myself on my network (and wiregaurd). it's mostly just for taking notes and managing my todos and setting automatic reminders. right now, it uses qwen (4b instruct + embedding + reranker) but I'm exploring more llms. nothing leaves the system and if a thing gets too complex, it delegates to Gemini to just understand what it should do (tool call etc, nothing still leaves the system, data is replaced with generic things). I couldn't be arsed to build a chat application so it's running a matrix server instead with just me and the assistant in a room. but now that it's proving to be something I might actually use, I'm thinking of building the whole thing up. I'm also storing all to-do state in a few org files instead of a db so that I can use it from Emacs but with sqlite built into Emacs 30, I might just switch to that instead. It's just easier to sync + reason in code.. org files are brittle to edit outside of Emacs. also just letting qwen write SQL statements �� in a tool call might be better than creating all those functions and filling up the context window. I'm also probably going to link it with my emails and other messaging so that I have a central place to process and auto-create todos. waiting on the first prompt injection attack too. I've kind of settled into the belief that ai/llms are just a new interface to our data and ui. no need to send it over the network to work with it. I'm sure I'll get rid of the Gemini dependency soon enough with a beefier halo strix or something. anyone else building personal things with this?

29

15 Comments

What if your co-op buddy wasn’t just a script, but a living entity learning from every mission? What if your in-game economy was balanced by an AI system that never slept, but always reasoned? And what if these weren’t just LiveOps tools... but the next layer of the game design canvas itself? In my latest article, I’m exploring how high-level AI and large-scale logic systems can reshape the way we build, balance, and imagine game worlds. Not through flashy NPC dialogue or overhyped generative tricks, but by embedding e.g., reasoning systems into the very operating layer of games themselves. 𝐑𝐞𝐚𝐝 𝐦𝐨𝐫𝐞 𝐡𝐞𝐫𝐞 👉 https://lnkd.in/dr-NJW8p #GameDevelopment #AI #VideoGames #GameDesign #SystemsDesign

13

4 Comments

At #PlatformSummit2025 and just listened to the most thought provoking talk by Kristen Womack. The amount of notes I have that are reminding me of all the special considerations we’re giving for AI agents and how we’ve done such a disservice to ourselves as human programmers. Such great efforts for making sure the AI does what we expect and so much of that should be in place for ourselves, our coworkers, and our customers. The semantic api descriptions, errors, etc clearly benefit AI agents but as a human those same systems would have been critically helpful when I was a junior just starting out or when onboarding to a new team/product. Even if I never end up implementing AI interactions with my current work, the lessons learned and the thoughts provoked are going to leave a lasting impact.

12

Today I used the term “brain vomit” in a meeting to describe what I’m doing in creating Copilot instruction files. I’ve used coding agents enough to know that while useful they have a tendency to use patterns I don’t immediately recognize and understand; or even like. I’m still just not comfortable giving agents large features to complete. I also personally find reusing common patterns and practices, whether solo or on a team, reduces overhead in reviewing, debugging, and making modifications. If you’ve ever had to work with many different teams with their own significantly different patterns and practices you’ll understand how much time gets wasted just trying to understand what you’re looking at. I’ve begun dumping (brain vomiting) my common preferred patterns and practices into instruction files. I structure my Lambda function files and the code within them in certain ways. I configure my DDB tables with a primary key named `pk` and sort key named `sk` while primary key values are prefixed with an item type. I almost never use the `Name` property on a resource in a CFN template. All of these are practices I developed for one reason or another and were often born out of lessons learned over time. To do this I started by using the Copilot CLI’s `/init` command in repos to generate instruction files based on the patterns the tool observes in my work. From there I’ve taken the instructions from the CLI’s output and used them to populate new instruction files targeted at specific technologies. (I prefer small topic based instruction files over large monolithic instruction files.) Next I’ve added more instructions based on memory or my own browsing through my projects. Finally I’ve been asking Copilot to suggest ways to simplify my instructions. My goal is to soon start creating coding agents with enough context that they are outputting code and building entire services in familiar looking ways. This lets me focus on evaluating how well the output functions and solves a problem rather than time spent figuring out how the output works and looking for subtle gotchas. Anyways, here’s the start of my collected patterns and practices. They’re mostly aimed at AWS serverless architectures. https://lnkd.in/esP6Jm5C #AWS #GitHub #Copilot

10

4 Comments

TIMING ASYMMETRY Displacement does not happen evenly. It happens in sequence. First: contractors. Then: new hires. Then: junior roles. Then: middle layers. Finally: senior roles: last, but hardest when it arrives. By the time senior roles are affected, escape velocity is gone. Layoffs are not the signal. They are the lagging indicator. By the time displacement is visible, retraining is already obsolete. — GRACIQ Institute #TimingAsymmetry #AIJobs #Automation #FutureOfWork #LaborReset #WorkforceShift #SystemsRisk #EconomicTransition #GRACIQ

1

Excited to share an open-source project I just released: ClaudeSettings, a macOS app for managing AI coding assistant configurations. Why?: When I started using Claude Code, it dramatically accelerated my development workflow. Projects that would have taken weeks took days. But this productivity came with an unexpected challenge—configuration management. With 10+ projects, each needing different AI tool settings (plugins, permissions, etc...), I lost visibility into what was configured where. Manual JSON editing became a pain. So I built ClaudeSettings to solve this workflow problem. It provides a visual interface for managing settings across all your projects, with drag-and-drop configuration management. The meta twist: I built it using Claude Code itself. It's now open source and available for the developer community. 🔗 GitHub: https://lnkd.in/gDVYW-zK 📝 Full story: https://lnkd.in/gbNfbgUW As AI-assisted development becomes standard practice, we'll need new categories of tools—not just for coding, but for managing the AI tooling itself. This is just the beginning. #ArtificialIntelligence #DeveloperTools #SoftwareDevelopment #OpenSource #Productivity #AIAssistedDevelopment

16

🎉 LongCat-Audio-Codec is officially OPEN SOURCED! 🚀 -an audio codec solution optimized specifically for Speech LLMs Key Breakthroughs: 1. Dual Tokens: Semantic and Acoustic Tokens are extracted in parallel at a low frame rate (16.7Hz / 60ms).This ensures both efficient modeling and full information integrity. 2. Ultra-Efficiency: LongCat-Audio-Codec maintains high intelligibility even at an extremely low bitrate, such as 0.43 kbps. 3. Real-Time Ready: Features a low-latency streaming decoder architecture. Latency is controlled to the hundred-millisecond level for real-time interaction. The integration of super-resolution in the decoder further enhances audio quality without extra models! This solution lowers technical barriers and optimizes resource efficiency for mobile/embedded Speech LLM deployment. 🔗Code: https://lnkd.in/gnzAze5y

65

I've had some fun writing lowish-level facilities/frameworks/libraries at my current gig. All in golang. #go * ReBAC system from scratch. * High performance internal event processing. Later extended to send events through REDIS streams (I wanted NATS, but the boss said, "no.") * A DI/wiring system for the close-to-100 or so sub-components built into the one-true-webapp supporting various front-end apps. * lots of other one-offs. It's easy to build "product" when the backend is performant and flexible.

3

3 Comments

I was out walking with my dog Dexter, daydreaming on the first properly warm day of the year. I was lost in my own mind mulling over a conversation I'd had with a fellow Game Developer about how we've adapted to the use of AI as software engineers. None of the existing labels fit. "Vibe coding", Karpathy's term, elicits a culture of care-free one-shotting with little to no regard for the code quality, just keep prompting until it runs. "Agentic engineering" has also drifted toward a fire-and-forget autonomy, where you describe a goal, the agent disappears for an hour, and returns with a pull request you merge in the quiet hope that nobody asks you about it later. Neither description fit the experiences that my colleague and I were having. What we do is closer to editing, so to my mind the term editorial engineering seems a more appropriate fit, and here's why. Firstly, it's worth being clear about which kind of editing I mean. Not text editing, not the typing itself. Editorial editing, the kind a magazine or book editor does. Commissioning work, reading it, sending it back for revision, holding it to a standard, putting your name on the thing that finally ships. In practice that means I provide a detailed spec, or I talk through a problem until a spec emerges. I let the agent write code when the stakes allow it, when the implementation is well-trodden, or when I just want a first draft to react to. Then I read what it wrote. I push back. I ask why a particular approach was taken. I request refactors when something offends my taste or violates the standards a piece of code needs to meet. The bar for an internal tool and the bar for client-facing production code are not the same, and the agent doesn't intuit which one we're operating under unless I tell it. Editing is real work There's a sleight of hand in a lot of the AI discourse where delegation gets treated as savings. The thinking goes, the agent writes the code, so you save the time it would have taken to write it. That framing misses what editors actually do, and it misses why editorial roles in publishing have existed for centuries despite the writers being perfectly capable of typing. A good editor reads carefully. They notice what isn't there as much as what is. They push back on structure, on pacing, on the choice of one word over another. They hold the writer to the standards of the publication. A tabloid editor and a literary editor both edit, but to wildly different ends. And they are answerable for what gets published. If something ships that shouldn't have, the editor's name is on it as much as the writer's. Editorial engineering inherits all of that...Follow the link below to read the full article. 📝 Originally published at https://lnkd.in/eCkj_tWn

1

I was skeptical and still remain skeptical about using LLMs for software development. However, over the past few months, I’ve been learning and experimenting with different platforms, models, and approaches, with the mindset that “it's just another tool I should evaluate.” When I’m skeptical about something, I get curious and push myself to learn as much as possible and gain hands-on experience. That helps me challenge my beliefs, form a more informed opinion, and potentially find something of value. During my experimentation, I took copious notes on what worked and what didn’t. I have now gone through my notes, cleaned them up, and used my learnings to create something I’ve named “Agentic Software Delivery Toolkit.” The name kind of sucks, but I couldn’t think of anything better. You can find it on GitHub: https://lnkd.in/eiUcNhzt It’s essentially an editor- and model-agnostic “framework” that aims to provide interactive, prompt-driven workflows for planning and building software using LLM-based agents. It produces a set of artifacts during the planning workflow that feed into the iterative implementation workflow. I’m currently using this toolkit to develop a few apps, and I will continue refining it as I learn more. It’s highly experimental and changing fast. Feel free to give it a try and let me know what you think. I’ve already received feedback that it’s difficult to understand how to get started, so I’ll probably update the README at some point to provide a more detailed step-by-step guide or a video in addition to the existing “Quick Start.”

21

8 Comments

TL;DR: I built a professional‑grade music system (Tenuto) with Rust/Wasm, a decoupled architecture, and AI as my integration engineer—proving one engineer can now deliver what once required a team. An AI review of my codebase pointed out something I hadn’t considered: Tenuto shares architectural DNA with platforms like Photoshop and Figma—a decoupled kernel, a multi‑language runtime, and a rigorous file format that acts as the single source of truth. Seeing my name mentioned alongside those giants felt surreal. They are the work of thousands; I’m a solo developer with a GitHub repo and zero funding. But it made me realize that the principles I applied—specification‑first, strict decoupling—are exactly the ones that scale. My approach: Specification first – I wrote the full Tenuto language spec before a single line of Rust. This gave me a blueprint that AI could follow, not guess at. Decoupled “narrow waist” – The compiler (Rust/Wasm) knows nothing about audio; the audio engine (WebAudio worklet) knows nothing about the compiler. They communicate via a lock‑free ring buffer. AI as co‑architect – I used Google AI Studio with a custom RAG blueprint that indexed my entire codebase. When I needed to refactor the core math engine, I didn’t need a team—I described the change, and the AI synchronised the Rust compiler, TypeScript workers, and hardware emitters in one session. The result worked immediately because the architecture was designed for that kind of decoupling. Tenuto is my “crown jewel.” It proves that with a rigid spec and a “sovereign architect” methodology, one person can own the entire vertical stack—from compiler math to WebGL pixels. I’m now open to new challenges in systems architecture, developer tools, or business infrastructure. If your team values industrial‑grade rigor and high‑velocity engineering, let’s talk. https://lnkd.in/gpYnZqvY #SystemsArchitecture #Rust #WebAssembly #BlackBoxMindset #SoftwareEngineering #AI #Innovation #SoloDev #MusicTech #GoogleAIStudio #OpenToWork

This is absolutely true. I would also add that just because AI decreases cycle time does not mean you should operate without a plan. To use an analogy, pretend you are going on a trip from New York to Los Angeles and fuel/electricity are free (or only cost pennies). Now imagine that you don't have a map but are just driving based on instinct. Because you are moving and the cost is low or zero, you feel you are getting somewhere even when you are not. You need a map (app or paper), or at least need to stop for directions occasionally. Movement, no matter the speed, is not progress unless it's toward where you want to go.

3

2 Comments

One of my favourite WebGPU demos is the "deferred rendering" demo (or as I call it, "disco dragon"). It's pretty, and it demonstrates a cool rendering technique for highly complex scenes with lots of dynamic lights: https://lnkd.in/eVE226HN So I rewrote it in Toucan, my graphics-oriented programming language: https://lnkd.in/e2Kwe334 (runs in Chrome and Firefox Nightly). It's 424 lines of Toucan, versus 801 total lines of WGSL and TypeScript. Most of the savings come on the host side, where, having defined our vertex buffers, uniform buffers, bind groups and pipeline variables once for the device side, we don't need to re-declare them for the host side in a new syntax. Plus, a common type system means there's no need to compute byte offsets or vertex strides, match up group numbers or bindings numbers, re-declare attachments, or accommodate std140 or std430 memory layouts. All of that is done automatically by the compiler. Type safety means not only being able to assign to members of a vertex or uniform buffer on the host using the same syntax as the device, but also applies to the usage itself: since the "vertex" and "uniform" qualifiers are understood by the host side, they become part of the type. If a required qualifier is omitted on allocation, attempting to bind the buffer as such will result in a compile-time error, not a runtime one. Here's a diff of the two versions (with comments and whitespace added to help the diffs to match): https://lnkd.in/ew64MGGS

8

7 Comments