Forgejo – Beyond coding. We forge.
https://forgejo.org/
Forgejo is a self-hosted lightweight software forge.
Easy to install and low maintenance, it just does the job.
Nerd Fonts - Iconic font aggregator, glyphs/icons collection, & fonts patcher
https://www.nerdfonts.com/#home
Iconic font aggregator, collection, and patcher
libvips
https://www.libvips.org/
libvips is a demand-driven, horizontally threaded image processing library. Compared to similar libraries, libvips runs quickly and uses little memory. libvips is licensed under the LGPL-2.1-or-later.
schapman1974/briskdb: Ordinary SQLite files, one sharded database—parallel writes, PostgreSQL, HTTP, Rust, Python, and shard-safe IDs.
https://github.com/schapman1974/briskdb
Ordinary SQLite files, one sharded database—parallel writes, PostgreSQL, HTTP, Rust, Python, and shard-safe IDs.
Soup Raiders Goes Native: What You Gain by Building Your Own Game Engine | Elias Farhan
https://eliasfarhan.ch/gamedev/cpp/2026/08/14/srnative-01-why-a-custom-engine.html
This post grew far beyond my original idea, but I wanted to set out my thoughts on building a custom engine before delving into the technology itself. Building an engine takes time, but it gives us control over how the game loads and updates, removes engine-licence fees, and teaches us about asset compilation, rendering, and optimisation. We can even expose parts of the engine to players, allowing them to improve the game or create mods (and potentially entirely new games) with our technology. After Unity’s runtime-fee announcement, technological independence became an even more important concern for game developers.
Use Task Runners for Common Coding Tasks - Ham Vocke
https://hamvocke.com/blog/task-runners/
Multiple ways to run common coding tasks in a convenient and consistent way across multiple repositories. This is not exactly rocket science. It’s a small quality of life improvement for you and your team. It’s super simple to set up and yet it’s something I rarely see in the wild. This could be one small thing you can implement while you’re having your first coffee tomorrow morning to do your good deed for the day.
LLMs reward expertise
https://www.seangoedecke.com/llms-reward-expertise/
The usefulness of domain knowledge suggests that human expertise will continue to be useful even as models get stronger. For many tasks, the human is the bottleneck, not the model, because the difficult part is in communicating to the model exactly what kind of solution the human wants. The information is “in the model” already, but it takes a very smart human to pull it out.
A Concrete Definition of “Product Sense” (and How to Build It) - NN/G
https://www.nngroup.com/articles/product-sense-definition/?ref=sidebar
Product sense is the ability to recognize when current problems match past successes or failures and reliably estimate how similar solutions will affect the desired outcomes.
Building Personal Software: Crafting Your Own Tools for Success
https://allen.hutchison.org/2025/11/28/the-era-of-personal-software/?ref=sidebar
We are entering the era of Personal Software. This is software written for an audience of one. It’s an application or a script built to solve a specific problem for a specific person, with no immediate intention of scaling, monetizing, or even sharing.
mcuadros/ofelia: A docker job scheduler (aka. crontab for docker)
https://github.com/mcuadros/ofelia
A docker job scheduler (aka. crontab for docker)
Blog on Jeremy Theocharis
https://www.theocharis.dev/blog/index.xml
</> htmx ~ Working With AI: A Concrete Example
https://htmx.org/essays/working-with-ai/
With respect to memory, while I can’t remember everything I used to be able to, I can understand things again very quickly with appropriate, er, prompting. AI is very good at helping me with this, and it lets me switch between open source projects and work projects much more efficiently than if I didn’t have it.
With respect to the long hours, AI is able to grind in a way that, even as a young developer, I would have had a difficult time keeping up with. This means, for example, I can have a much more extensive test suite for my projects than I would have otherwise.
Looking at the tests that Claude generated in this case, they are more extensive than what I probably could have mustered the energy to do myself.
So AI has addressed two fundamental (relative) weaknesses I have developed as an older developer.
I love LLMs, I hate hype | the singularity is nearer
https://geohot.github.io//blog/jekyll/update/2026/07/12/i-love-llms.html
AI is the continuation of the computer revolution. I love computers so much.
The Tragedy of the Engineering Commons
https://ianreppel.org/the-tragedy-of-the-engineering-commons/
The surest way to ruin an engineering team is to believe it will survive whatever you do to it.
Leave a failing test before you go on vacation - Freek Van der Herten's blog on Laravel, PHP and AI
https://freek.dev/3156-leave-a-failing-test-before-you-go-on-vacation
Every year I dread coming back from vacation not because of the work, but because I have no idea where I left off. A failing test, a well-written TODO, and a slow first day back are all you need to ease back in.
golanlevin/p5-single-line-font-resources: An archive of monoline vector fonts, and p5.js code to render them.
https://github.com/golanlevin/p5-single-line-font-resources/
An archive of monoline vector fonts, and p5.js code to render them.
The good times in tech are over
https://www.seangoedecke.com/good-times-are-over/
If I had to choose, I’d definitely choose to return to the job market of the 2010s, so I can be paid more to work less and have more job security. I’m not an idiot. But the silver lining to actually having to ship is that you’re no longer living in a dream. If you’re realistic about how things work, the job of software engineering becomes much easier to understand:
Providing value to the company gets you rewarded
Not providing value to the company gets you punished
“Value to the company” means furthering the explicit plans of your company’s executives
The just-say-no engineer was a ZIRP phenomenon
https://www.seangoedecke.com/the-just-say-no-engineer-was-a-zirp-phenomenon/
Some senior and staff engineers operate as gatekeepers, slowing down development and saying no to most things
This was a critical role during ZIRP, because:
Tech companies had thousands of engineers who were empowered to do basically whatever they wanted, so without gatekeeping the systems would have fallen apart
Tech companies didn’t care that much if they got anything done
When ZIRP ended, the environment for this kind of engineer became much worse, since tech companies were now actually focused on accomplishing things and the “do whatever you want” era was over
Like with layoffs, this shift is often blamed on AI, but it would have happened even if powerful LLMs had not emerged at all. It’s an end-of-ZIRP phenomenon
notes: copilot edited an ad into my pr
https://notes.zachmanson.com/copilot-edited-an-ad-into-my-pr/
After a team member summoned Copilot to correct a typo in a PR of mine, Copilot edited my PR description to include and ad for itself and Raycast.
Lines of Code Are Back (And It's Worse Than Before)
https://www.thepragmaticcto.com/p/lines-of-code-are-back-and-its-worse
The metric we killed is back, and AI made it worse
Computers can be understood - Made of Bugs
https://blog.nelhage.com/post/computers-can-be-understood/
Computers are complex, but need not be mysteries. Any question we care to ask can, in principle and usually even in practice, be answered. Unknown systems can be approached with curiosity and determination, not fear.
AddyOsmani.com - Agentic Engineering
https://addyosmani.com/blog/agentic-engineering/?ref=sidebar
The irony is that AI-assisted development actually rewards good engineering practices more than traditional coding does. The better your specs, the better the AI’s output. The more comprehensive your tests, the more confidently you can delegate. The cleaner your architecture, the less the AI hallucinates weird abstractions. As one analysis noted, “AI didn’t cause the problem; skipping the design thinking did.”
Coding agents as the new compilers - Anil Dash
https://www.anildash.com/2026/02/11/coding-agents-as-the-new-compilers/
But the response to that skepticism is not to reject the category of technology, but rather to capture it and seize control over its direction, away from the Big AI companies. This shift to a new level of coding abstraction is exactly the kind of platform shift that presents that sort of opportunity. It’s potentially a chance for coders to be in control of some part of their destiny, at a time when a lot of bosses clearly want to get rid of as many coders as they can.
At the very least, this is one area where the people who actually make things are ahead of the big platforms that want to cash in on it.
A quote from Chris Lloyd
https://simonwillison.net/2026/Jan/22/chris-lloyd/#atom-everything
Most people's mental model of Claude Code is that "it's just a TUI" but it should really be closer to "a small game engine".
For each frame our pipeline constructs a scene graph with React then:
-> layout elements
-> rasterize them to a 2d screen
-> diff that against the previous screen
-> finally use the diff to generate ANSI sequences to draw
We have a ~16ms frame budget so we have roughly ~5ms to go from the React scene graph to ANSI written.
How I estimate work as a staff software engineer
https://www.seangoedecke.com/how-i-estimate-work/
It is not possible to accurately estimate software work. Software projects spend most of their time grappling with unknown problems, which by definition can’t be estimated in advance. To estimate well, you must therefore basically ignore all the known aspects of the work, and instead try and make educated guesses about how many unknowns there are, and how scary each unknown is.
Many Small Queries Are Efficient In SQLite
https://www.sqlite.org/np1queryprob.html
N+1 Queries Are Not A Problem With SQLite
SQLite is not client/server, however. The SQLite database runs in the same process address space as the application. Queries do not involve message round-trips, only a function call. The latency of a single SQL query is far less in SQLite. Hence, using a large number of queries with SQLite is not the problem.
EmNudge/watlings: Learn WebAssembly by writing small programs!
https://github.com/EmNudge/watlings
Learn the WebAssembly Text Format
by fixing a bunch of small programs!
Software craftsmanship is dead
https://www.pcloadletter.dev/blog/craftsmanship-is-dead/
I feel like it's been forever since I had a conversation about craftsmanship on the job. It's possible I have just found myself in the wrong places time and time again.
Or maybe, and this is something I really fear, maybe the people who truly focus on the craft of software engineering are retiring or getting run off.
2025: The year in LLMs
https://werd.io/2025-the-year-in-llms/
I also think we’re going to see a real split in the tech industry (and everywhere code is written) between people who are outcome-driven and are excited to get to the part where they can test their work with users faster, and people who are process-driven and get their meaning from the engineering itself and are upset about having that taken away. (This is not to say that there aren’t many issues with AI aside from these things, of course.)
Origin private file system - Web APIs | MDN
https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system
The origin private file system (OPFS) is a storage endpoint provided as part of the File System API, which is private to the origin of the page and not visible to the user like the regular file system. It provides access to a special kind of file that is highly optimized for performance and offers in-place write access to its content.
I got hacked, my server started mining Monero this morning. | Unfinished Side Projects
https://blog.jakesaunders.dev/my-server-started-mining-monero-this-morning/
TL;DR
Umami analytics (built with Next.js) had an RCE vulnerability.
Got exploited, installed cryptominers
Mined Monero for 10 days at 1000%+ CPU
Container isolation saved me because it ran as non-root with no mounts
Fix: docker rm umami and enable firewall
Lesson: Know what your dependencies are built with, and configure containers properly
Your job is to deliver code you have proven to work
https://simonwillison.net/2025/Dec/18/code-proven-to-work/#atom-everything
As software engineers we don’t just crank out code—in fact these days you could argue that’s what the LLMs are for. We need to deliver code that works—and we need to include proof that it works as well. Not doing that directly shifts the burden of the actual work to whoever is expected to review our code.
What Actually Makes You Senior – Terrible Software
https://terriblesoftware.org/2025/11/25/what-actually-makes-you-senior/
But if you strip away the title, the salary, and the years of experience, there’s one core skill that separates senior+ engineers from everyone else: reducing ambiguity. Everything else flows from that.
Resonant Computing Manifesto
https://resonantcomputing.org/
We suggest these five principles as a starting place:
Private: In the era of AI, whoever controls the context holds the power. While data often involves multiple stakeholders, people must serve as primary stewards of their own context, determining how it's used.
Dedicated: Software should work exclusively for you, ensuring contextual integrity where data use aligns with your expectations. You must be able to trust there are no hidden agendas or conflicting interests.
Plural: No single entity should control the digital spaces we inhabit. Healthy ecosystems require distributed power, interoperability, and meaningful choice for participants.
Adaptable: Software should be open-ended, able to meet the specific, context-dependent needs of each person who uses it.
Prosocial: Technology should enable connection and coordination, helping us become better neighbors, collaborators, and stewards of shared spaces, both online and off.
We should all be using dependency cooldowns
https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependency-cooldowns
Dependency cooldowns are a free, easy, and incredibly effective way to mitigate the large majority of open source supply chain attacks. More individual projects should apply cooldowns (via tools like Dependabot and Renovate) to their dependencies, and packaging ecosystems should invest in first-class support for cooldowns directly in their package managers.
I have seen the compounding teams - by Sam Schillace
https://sundaylettersfromsam.substack.com/p/i-have-seen-the-compounding-teams
The compounding comes from a “build a tool for making a tool” recursive mindset. These teams will automate everything they can, and will often tell the coding system “you’ll need a tool for that, go ahead and build and use it” - and then the system will do just that, checking it in to git and making it a permanent improvement.
The 4 types of technical documentation - Nick's Blog and Digital Garden
https://nick.groenen.me/posts/the-4-types-of-technical-documentation/
Tutorials, which are learning-oriented, practical steps.
How-to guides, which are task-oriented, practical steps.
Technical references, which capture information-oriented, theoretical knowledge.
Explanations (or discussions), which capture understanding-oriented, theoretical knowledge.
cdzombak/newt at dzombak.com
https://github.com/cdzombak/newt?ref=dzombak.com
Manage Git worktrees with ease. newt is a simple wrapper around Git worktrees that automatically organizes them in a .newt/ directory, provides merge status tracking, and handles deletion.
Your vibe coded slop PR is not welcome
https://samsaffron.com/archive/2025/10/27/your-vibe-coded-slop-pr-is-not-welcome
A ready to review PR is the traditional PRs we submit.
We reviewed all the machine generated code and vouch for all of it. We ran the tests and like the tests, we like the code structure, we read every single line of code carefully we also made sure the PR meets a project’s guidelines.
Using Homebrew to Distribute Early Access Binaries from Private Github Repositories :: LGUG2Z
https://lgug2z.com/articles/using-homebrew-to-distribute-early-access-binaries-from-private-github-repositories/
After setting up nightly builds on GitHub Actions, I wanted to create a Homebrew Tap and Formula for people who sponsor me on GitHub for early access - being able to brew install is a much more pleasant onboarding experience for a new sponsor than having to compile from source.
You already have a git server: (Maurycy's blog)
https://maurycyz.com/misc/easy_git/
If you have a git repository on a server with ssh access, you can just clone it:
15 Go Subtleties You May Not Already Know
https://harrisoncramer.me/15-go-sublteties-you-may-not-already-know/
One of the best ways to learn something new is to write down something you’ve learned about it regularly. Over the past year, I’ve been doing this with the Go programming language. Here are some of my favorite lesser-known tidbits about the language.
Running Pull Requests in Github Codespaces - These Yaks Ain’t Gonna Shave Themselves
https://polotek.net/posts/running-pull-requests-in-github-codespaces/
Here’s the idea. I have a solo project that I’m working on, and instead of hacking away on the main branch, I’m using a full feature branch and pull request workflow to keep my changes organized. This might seem like overkill, but it’s helpful for me because I tend to bounce around and leave things half done. I can run things locally and test different things by switching between branches. But I’m also doing a lot more AI-assisted development. Locally I use Claude Code. But I’ve been experimenting with allowing Github Copilot to create PRs. I create a github issue, assign it to copilot, and it spins up in the cloud and does work. Afterwards it opens a pull request for me to review. So even though this is a “solo” project, I end up with pull requests that I didn’t write myself and I need to validate.
Argo Workflows - The workflow engine for Kubernetes
https://argo-workflows.readthedocs.io/en/latest/
Argo Workflows is an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes. Argo Workflows is implemented as a Kubernetes CRD (Custom Resource Definition).
coughlanio/pocketcasts: Node.js Client Library for interacting with PocketCasts API.
https://github.com/coughlanio/pocketcasts
Node.js Client Library for interacting with PocketCasts API.
Claude Code for web—a new asynchronous coding agent from Anthropic
https://simonwillison.net/2025/Oct/20/claude-code-for-web/#atom-everything
Anthropic launched Claude Code for web this morning. It’s an asynchronous coding agent—their answer to OpenAI’s Codex Cloud and Google’s Jules, and has a very similar shape. I had preview access over the weekend and I’ve already seen some very promising results from it.
Don't let Claude Code delete your session logs
https://simonwillison.net/2025/Oct/22/claude-code-logs/
Unfortunately Claude Code has a nasty default behavior of deleting these after 30 days! You can't disable this entirely, but you can at least delay it for 274 years by adding this to your ~/.claude/settings.json file:
{
"cleanupPeriodDays": 99999
}
Living dangerously with Claude
https://simonwillison.net/2025/Oct/22/living-dangerously-with-claude/#atom-everything
I gave a talk last night at Claude Code Anonymous in San Francisco, the unofficial meetup for coding agent enthusiasts. I decided to talk about a dichotomy I’ve been struggling with recently. On the one hand I’m getting enormous value from running coding agents with as few restrictions as possible. On the other hand I’m deeply concerned by the risks that accompany that freedom.
cdzombak/feedfilter: RSS feed filtering tool
https://github.com/cdzombak/feedfilter/tree/main
RSS feed filtering tool
The joy of rediscovering Perl - Eskild Hustvedt
https://blog.zerodogg.org/2025/10/13/the-joy-of-rediscovering-perl/
Lately I've gotten a lot back into Perl-programming, and it has honestly been an absolute delight.
Software can be finished - Ross Wintle
https://rosswintle.uk/2025/10/software-can-be-finished/?ref=sidebar
There is a utopia where we write correct, bug-free, fast, secure, statically-built software with zero dependencies that does it’s job and will continue doing it’s job as long as the platform it’s written for endures. This feels like it should be a thing we strive for. It feels like a Good Thing (TM)
Embracing the parallel coding agent lifestyle
https://simonwillison.net/2025/Oct/5/parallel-coding-agents/#atom-everything
I can only focus on reviewing and landing one significant change at a time, but I’m finding an increasing number of tasks that can still be fired off in parallel without adding too much cognitive overhead to my primary work.
AI and Home-Cooked Software | Karan Sharma
https://mrkaran.dev/posts/ai-home-cooked-software/
I’ve been noticing a new pattern: people with deep domain knowledge but no coding experience are now building their own tools. Armed with AI assistants, they can create custom workflows in a matter of days, bypassing traditional development cycles. Are these solutions production-ready? Not even close. But they solve urgent, specific problems, and that’s what matters. Tasks that once required weeks of specialized training are quickly becoming weekend projects.
charmbracelet/crush: The glamourous AI coding agent for your favourite terminal 💘
https://github.com/charmbracelet/crush
Your new coding bestie, now available in your favourite terminal.
Your tools, your code, and your workflows, wired into your LLM of choice.
RooCodeInc/Roo-Code: Roo Code gives you a whole dev team of AI agents in your code editor.
https://github.com/RooCodeInc/Roo-Code
Roo Code gives you a whole dev team of AI agents in your code editor.
Using GraphViz for CLAUDE.md
https://blog.fsck.com/2025/09/29/using-graphviz-for-claudemd/
One of the things that I thought they said during the talk was that they were using .dot (GraphViz) as the language that they are using as the formalization for new processes for their coding agent. It made sense to me. There's enough dot on the Internet that models can read and understand it quite well. And it removes a whole bunch of the ambiguity of English language specifications.
obra/private-journal-mcp: A lightweight MCP server that provides Claude with a private journaling capability to process feelings and thoughts
https://github.com/obra/private-journal-mcp
A lightweight MCP server that provides Claude with a private journaling capability to process feelings and thoughts
My agentic coding methodology of June 2025
https://blog.fsck.com/2025/06/24/my-agentic-coding-methodology-of-june-2025/
I was chatting with some friends about how I'm using "AI" tools to write code. Like everyone else, my process has been evolving over the past few months. It seemed worthwhile to do a quick writeup of how I'm doing stuff today.
90% | Armin Ronacher's Thoughts and Writings
https://lucumr.pocoo.org/2025/9/29/90-percent/
For me, this has reached the point where I can’t imagine working any other way. Yes, I could probably have done it without AI. But I would have built a different system in parts because I would have made different trade-offs. This way of working unlocks paths I’d normally skip or defer.
meks.quest
https://meks.quest/blogs/the-theatre-of-pull-requests-and-code-review
A key part of having a reviewable PR is writing commits that tell a story. Present your changes incrementally and logically so reviewers can follow your thought process. Generic commit messages such as "add dependency," "implement file upload feature," and "address PR feedback" don’t tell much of a story and leave reviewers guessing. Why was the dependency added? What were the specific steps in creating the file uploader feature? What feedback is being addressed?
Building the Hundred-Year Web Service with htmx - Alexander Petros - YouTube
https://www.youtube.com/watch?v=lASLZ9TgXyc
In the fast-moving JS ecosystem, keeping your software current can be a huge drain on resources. But what if there was way to write software that had minimal maintenance burden today and didn't inspire dread in the junior developers of tomorrow? Built into the web platform are all the capabilities necessary to create useful, networked services that last for decades—we just have to build in ways that takes advantage of them.
You Want Technology With Warts
https://entropicthoughts.com/you-want-technology-with-warts
Every single wart that annoys us today, used to be a reasonable feature that someone relied on in their production code. Every wart we see today is a testament to the care the maintainers put into backward compatibility. If we choose a technology today, we want one that saves us from future maintenance by keeping our wartful code running – even if we don’t yet know it is wartful. The best indicator of this is whether the technology has warts today.
Git exclude, a handy feature you might not know about / Marijke Luttekes
https://marijkeluttekes.dev/blog/articles/2025/09/03/git-exclude-a-handy-feature-you-might-not-know-about/
Exclude is particularly handy when you want to keep personal, non-standard files in a repository that is not yours, and where you cannot update its ignore files willy-nilly.
Spec-driven development with AI: Get started with a new open source toolkit - The GitHub Blog
https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/
Setting up cgit with Caddy v2 - SixFoisNeuf
https://www.sixfoisneuf.fr/posts/setting-up-cgit-with-caddy2/
What follows GitHub? · Applied Cartography
https://jmduke.com/posts/post/github-next/
I’m not well equipped to prognosticate here: all I know is that this is not the tool of the future, and whoever replaces GitHub will have a narrative arc of incumbency displacement that will feel obvious and trite in retrospect.
inessential: Writing Mac and iOS Apps Shouldn’t Be So Difficult
https://inessential.com/2025/08/28/easy-app-writing.html
I’m not saying apps these days need to be Frontier-like in any details. But it seems absolutely bizarre to me that we — we who write Mac and iOS apps — still have to build and run the app, make changes, build and run the app, and so on, all day long. In the year 2025.
Modifying Other People's Software | natkr's ramblings
https://natkr.com/2025-08-14-modifying-other-peoples-software/
What if we could just.. import our patchset into Git, at the start of our session, and then export it back out as a series of patch files when we're done? That way we're effectively following the commandments of The Holy Quiltmother, but still get to keep our familiar Git UI.
How I program with Agents - crawshaw - 2025-06-08
https://crawshaw.io/blog/programming-with-agents
It is easy for the haughty to disregard the work of gluing well-known APIs together as “not real” programming, but it has been the practical experience of my career that for every hour of truly interesting programming I can do, I have had to do 10 or more hours of dreary work with APIs, libraries, dysfunctional compilers, build systems, or obtuse package managers to actually make that hour useful. Having a tool that lets me do 30 minutes of “not real” programming by writing a few carefully constructed sentences, and lets me vacuum the kids' room while it works, preserves momentum.
operators, not users and programmers
https://jyn.dev/operators-not-users-and-programmers/
spreadsheets are hugely successful. Felienne Hermans, who has spent her career studying spreadsheets, attributes this success to "their immediate feedback system and their continuous deployment model": the spreadsheet shows you its result as soon as you open it, and it requires no steps to run other than to install Excel and double-click the file.
Fun with uv and PEP 723
https://www.cottongeeks.com/articles/2025-06-24-fun-with-uv-and-pep-723
For the longest time, I have been frustrated with Python because I couldn’t use it for one-off scripts. I had to first ensure it was running in an environment where it could find the right Python version and the dependencies installed. That is now a thing of the past.
My LLM codegen workflow atm | Harper Reed's Blog
https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/
tl:dr; Brainstorm spec, then plan a plan, then execute using LLM codegen. Discrete loops. Then magic. ✩₊˚.⋆☾⋆⁺₊✧
Peer Programming with LLMs, For Senior+ Engineers
https://pmbanugo.me/blog/peer-programming-with-llms
This article is a collection of blog posts written by other senior or staff+ engineers exploring the use of LLM in their work, without the usual hype or buzzwords from the usual suspects. I hope you find them useful and inspiring.
Mystical
https://suberic.net/~dmm/projects/mystical/README.html
I wanted to make a programming language that resembled magical circles. This is more like a way to write PostScript that looks like a magical circle, but I will refer to it as Mystical in this document.
Beyond Text-Only AI: On-Demand UI Generation for Better Conversational Experiences - fka.dev
https://blog.fka.dev/blog/2025-05-16-beyond-text-only-ai-on-demand-ui-generation-for-better-conversational-experiences/
Explore how AI-generated user interfaces can enhance human-AI interaction by dynamically creating the right interface components at the right time, addressing key limitations of text-only interactions.
Building software on top of Large Language Models
https://simonwillison.net/2025/May/15/building-on-llms/#atom-everything
I presented a three hour workshop at PyCon US yesterday titled Building software on top of Large Language Models. The goal of the workshop was to give participants everything they needed to get started writing code that makes use of LLMs.
Something Pretty Right: A History of Visual Basic | Retool
https://retool.com/visual-basic
How Visual Basic became the world's most dominant programming environment, its sudden fall from grace, and why its influence is still shaping the future of software development.
Vibe Coding is not an excuse for low-quality work
https://addyo.substack.com/p/vibe-coding-is-not-an-excuse-for
A field guide to responsible AI-assisted development
An LLM Codegen Hero's Journey | Harper Reed's Blog
https://harper.blog/2025/04/17/an-llm-codegen-heros-journey/
This is my journey. It is largely the path I took. I think you could speed run it if you were compelled. I don’t think you need to follow every step, but I do think every step is additive.
Citronics, meet the world’s first Circular Microcomputers
https://citronics.eu/
The embedded computers powered by repurposed smartphone components.
AI Blindspots | AI Blindspots
https://ezyang.github.io/ai-blindspots/
Blindspots in LLMs I’ve noticed while AI coding. Sonnet family emphasis. Maybe I will eventually suggest Cursor rules for these problems.
team pico
https://blog.pico.sh/
We think of pico.sh as a hacker lab where we can experiment with new ways to interact with the web.
hacker labs · pico.sh
https://pico.sh/
Our services allow users to publish content without needing to install anything. We accomplish this with the SSH tools (rsync, sftp, sshfs) you already have installed on your system.
Horseless intelligence | Ned Batchelder
https://nedbatchelder.com/blog/202503/horseless_intelligence.html
OK, so AI doesn’t think the same way that people do. I’m fine with that. What’s important to me is that it can do some work for me, work that could also be done by people thinking. Cars (“horseless carriages”) do work that used to be done by horses running. No one now complains that cars work differently than horses.
Literate Development: AI-Enhanced Software Engineering
https://substack.com/home/post/p-160183664
By emphasizing documentation as the primary source of truth, establishing explicit linkages between development artifacts, and employing iterative, human-guided prompting, the whole team can harness the power of LLMs while mitigating their current limitations.
Building a Firecracker-Powered Course Platform To Learn Docker and Kubernetes
https://iximiuz.com/en/posts/iximiuz-labs-story/
This is a long overdue post on iximiuz Labs' internal kitchen. It'll cover why I decided to build my own learning-by-doing platform for DevOps, SRE, and Platform engineers, how I designed it, what technology stack chose, and how various components of the platform were implemented. It'll also touch on some of the trade-offs that I had to make along the way and highlight the most interesting parts of the platform's architecture. In the end, I'll, of course, share my thoughts on what's next on the roadmap. Sounds interesting? Then brace for a long read!
"Vibe Coding" vs Reality
https://cendyne.dev/posts/2025-03-19-vibe-coding-vs-reality.html
"Vibe Coding" might get you 80% the way to a functioning concept. But to produce something reliable, secure, and worth spending money on, you’ll need experienced humans to do the hard work not possible with today’s models.
Verification-First Development • Buttondown
https://buttondown.com/hillelwayne/archive/verification-first-development/
before writing code, put in place some means of verifying that the code is correct, or at least have an idea of what you'll do.
Verifiability is the Limit
https://alperenkeles.com/posts/verifiability-is-the-limit/
I now, although tentatively, believe that LLMs can indeed succeed in all domains with perfect oracles.
1x Engineer
https://1x.engineer/
You might have already heard of a 10x engineer. Probably too often, actually. If there's such a thing as a 10x engineer, surely there must be a 1x engineer, too?
Of course there is! Let's dig into a non-exhaustive list of what qualities make up a 1x engineer.
It's not cheating if you write the video game solver yourself | Robert Heaton
https://robertheaton.com/cocoon/
My son asked if I’d beaten my game. I explained that I’d transcended it by creating a mathematical representation of its entire possibility space. He asked if that meant “no.”
Here’s how I use LLMs to help me write code
https://simonwillison.net/2025/Mar/11/using-llms-for-code/
Using LLMs to write code is difficult and unintuitive. It takes significant effort to figure out the sharp and soft edges of using them in this way, and there’s precious little guidance to help people figure out how best to apply them.
If someone tells you that coding with LLMs is easy they are (probably unintentionally) misleading you. They may well have stumbled on to patterns that work, but those patterns do not come naturally to everyone.
I’ve been getting great results out of LLMs for code for over two years now. Here’s my attempt at transferring some of that experience and intution to you.
Stewardship over ownership | nicole@web
https://ntietz.com/blog/stewardship-over-ownership/
A steward doesn't jealously guard, or struggle to gain more power. A steward watches what her responsibilities are, ensuring enough to contribute but not so many as to burn out. And she nurtures and cares for the code, to make sure that it continues to serve its purpose. Instead of an adversarial relationship, stewardship promotes partnership: It promotes working with others to figure out how to make the best use of resources, instead of hoarding them for yourself.
Tailscale is pretty useful | Fatih's Personal Blog
https://blog.6nok.org/tailscale-is-pretty-useful/
It’s probably old news for most, but I’ve recently started using Tailscale and wanted to share my experience with it.
Chat is a bad UI pattern for development tools—Daniel De Laney
https://danieldelaney.net/chat/?ref=sidebar
The first company to get this will own the next phase of AI development tools. They’ll build tools for real software instead of toys. They’ll make everything available today look like primitive experiments.
What to do about SQLITE_BUSY errors despite setting a timeout
https://simonwillison.net/2025/Feb/17/sqlite-busy/#atom-everything
I've written about this a few times before, so I just started a sqlite-busy tag to collect my notes together on a single page.
What to do about SQLITE_BUSY errors despite setting a timeout - Bert Hubert's writings
https://berthub.eu/articles/posts/a-brief-post-on-sqlite3-database-locked-despite-timeout/
The tl;dr on this, to prevent SQLITE_BUSY errors even when setting a timeout, don’t ever upgrade transactions to read-write. If you know you are going to write in a transaction, use ‘BEGIN IMMEDIATE’, or start off with the write. But do read on for why this is so, and how other databases struggle with this problem as well.
1KB Frontend Library - DEV Community
https://dev.to/fedia/1kb-frontend-library-5ef1?
Our compact signals implementation is inspired by Andrea Giammarchi’s excellent article on signals. If you’re curious about the nitty-gritty, I highly recommend giving it a read.
Programmatics Paper Hex Calculator - Programmatics_Paper_Hex_Calculator.pdf
http://www.brutman.com/Programmatics_Paper_Hex_Calculator.pdf
How I code with LLMs these days
https://www.phillipcarter.dev/posts/coding-with-llms
To me, all signs point towards software engineering changing radically as a profession to be much more oriented around the what and why of software, and much less around the how. This will cause disruption at a massive scale in the long run. But in the short run, it's just a lot of fun to play with these tools and see what they can do.
How I use LLMs as a staff engineer | sean goedecke
https://www.seangoedecke.com/how-i-use-llms/
Personally, I feel like I get a lot of value from AI. I think many of the people who don’t feel this way are “holding it wrong”: i.e. they’re not using language models in the most helpful ways. In this post, I’m going to list a bunch of ways I regularly use AI in my day-to-day as a staff engineer.
Ignore the Grifters - AI Isn't Going to Kill the Software Industry — Dustin Ewers
https://dustinewers.com/ignore-the-grifters/
I feel like half of my social media feed is composed of AI grifters saying software developers are not going to make it. Combine that sentiment with some economic headwinds and it's easy to feel like we're all screwed. I think that's bullshit. The best days of our industry lie ahead.
Learn Yjs by Jamsocket
https://learn.yjs.dev/
Learn Yjs starts with the basics of Yjs, then covers techniques for handling state in distributed applications. We’ll talk about what a CRDT is, and why you’d want to use one. We’ll get into some of the pitfalls that make collaborative applications difficult and show how you can avoid them. There will be explorable demos and code exercises so you can get a feel for how Yjs really works.
A Gentle Introduction to WebAssembly in Rust (2025 Edition) - DEV Community
https://dev.to/marktolmacs/a-gentle-introduction-to-webassembly-in-rust-2025-edition-1iac?utm_medium=FuckOff&utm_source=FuckOff
So in this guide we’ll walk through setting up the tooling and development environment for building and using WebAssembly in Rust, embedding it in a TypeScript project, review how communication between TypeScript and Rust can happen, then finally how you can debug your WebAssembly directly in the browser and/or your favorite IDE. I will use Visual Studio Code as the IDE and Chrome as the browser, but apart from some debugging options, you can reproduce these in your tool of choice.
crawshaw - 2025-01-06
https://crawshaw.io/blog/programming-with-llms
This document is a summary of my personal experiences using generative models while programming over the past year. It has not been a passive process. I have intentionally sought ways to use LLMs while programming to learn about them. The result has been that I now regularly use LLMs while working and I consider their benefits net-positive on my productivity. (My attempts to go back to programming without them are unpleasant.)
All-Hands-AI/OpenHands: 🙌 OpenHands: Code Less, Make More
https://github.com/All-Hands-AI/OpenHands?tab=readme-ov-file
Welcome to OpenHands (formerly OpenDevin), a platform for software development agents powered by AI.
OpenHands agents can do anything a human developer can: modify code, run commands, browse the web, call APIs, and yes—even copy code snippets from StackOverflow.
Advent of Code on the Nintendo DS
https://sailor.li/aocnds.html
The problem with Advent of Code is that it is a waste of time. Most of the puzzles are in the realm of either string processing (somewhat applicable to programming), logic puzzles (not really applicable to most programming), or stupid gotchas in the input format (annoyingly, very applicable to most programming). So to combat this a lot of people use Advent of Code as an excuse to learn a new programming language that they wouldn't otherwise have a reason to use.
Programming the C64 with Visual Studio Code - Retro Game Coders
https://retrogamecoders.com/c64-visual-studio-code/
Surprise! You can code for the C64, for free, using Microsoft Visual Studio Code!
Welcome to TrailBase | TrailBase
https://trailbase.io/
A blazingly fast, open-source application server with type-safe APIs, built-in JS/ES6/TS Runtime, Auth, and Admin UI built on Rust, SQLite & V8.
I Like Makefiles
https://switowski.com/blog/i-like-makefiles/
The reason I like makefiles is that they often follow an unwritten convention of implementing the same set of commands to get you up and running. When I find a project I know nothing about, and I see a Makefile file inside, chances are that I can run make or make build followed by make install, and I will get this project built and set up on my computer. Or at least I will get information on other steps I need to include.
Implementing Filtered Semantic Search Using Pgvector and JavaScript
https://www.timescale.com/blog/implementing-filtered-semantic-search-using-pgvector-and-javascript-2/
Conventional search methods rely on keyword matching, where the system locates exact words or phrases from the query within documents. This technique can be enhanced to better capture the context and intent behind the user's query, leading to more relevant and precise search results. Semantic search focuses on understanding the meaning and intent behind the query. Combining semantic search with filters—or additional parameters to narrow the results based on specific attributes—further improves accuracy.
In this article, we explore semantic search with filters and demonstrate how you can implement it using pgvector and JavaScript.
Nobody Gets Fired for Picking JSON, but Maybe They Should? · mcyoung
https://mcyoung.xyz/2024/12/10/json-sucks/
JSON is extremely popular but deeply flawed. This article discusses the details of JSON’s design, how it’s used (and misused), and how seemingly helpful “human readability” features cause headaches instead. Crucially, you rarely find JSON-based tools (except dedicated tools like jq) that can safely handle arbitrary JSON documents without a schema—common corner cases can lead to data corruption!
(blog also has a neato minimap view of the whole entry on the side, like VSCode)
Tabloid: the clickbait headline programming language
https://tabloid.vercel.app/
Tabloid is a turing-complete programming language for writing programs in the style of clickbait news headlines.
The 70% problem: Hard truths about AI-assisted coding
https://addyo.substack.com/p/the-70-problem-hard-truths-about
AI isn't making our software dramatically better because software quality was (perhaps) never primarily limited by coding speed. The hard parts of software development – understanding requirements, designing maintainable systems, handling edge cases, ensuring security and performance – still require human judgment.
What AI does do is let us iterate and experiment faster, potentially leading to better solutions through more rapid exploration. But only if we maintain our engineering discipline and use AI as a tool, not a replacement for good software practices. Remember: The goal isn't to write more code faster. It's to build better software. Used wisely, AI can help us do that. But it's still up to us to know what "better" means and how to achieve it.
Why we left Fly.io - Chris Arderne
https://rdrn.me/why-we-left-fly/
So why did we ditch Fly? In the end it came down to the following four things. Until these are improved, I’d be unlikely to recommend it for Production™ work.
heaversm/llamafile-code-completion: Use llamafile to generate inline code completions in react / next.js apps.
https://github.com/heaversm/llamafile-code-completion
Use llamafile to generate inline code completions in react / next.js apps.
Creating a Proxmox or QEMU ChromeOS Flex VM | Kevin David
https://kevindavid.org/code/2024/03/20/chrome-os-flex-proxmox.html
I recently wanted to experiment with ChromeOS Flex but didn’t want to install it on a physical machine. I also was doing this without a USB key, which complicated things slightly.
After some trial and error, there are two non-obvious steps to get the installer running:
Properly mounting the .bin live USB image in a way that’s accessible to the VM
Setting graphics drivers to something ChromeOS Flex supports, which enables the VM to successfully boot the live USB image
How Much Memory Do You Need in 2024 to Run 1 Million Concurrent Tasks?
https://hez2010.github.io/async-runtimes-benchmarks-2024/
Finally, C# undoubtedly beat all other languages; it's very competitive and has really become a monster. And as expected, Rust continues to do a good job on memory efficiency.
The distance between Go and the others increased. Now Go loses by over 13 times to the winner. It also loses by over 2 times to Java, which contradicts the general perception of the JVM being a memory hog and Go being lightweight.
wesql/wesql: WeSQL is an innovative MySQL distribution that adopts a compute-storage separation architecture, with storage backed by S3 (and S3-compatible systems). It can run on any cloud, ensuring no vendor lock-in.
https://github.com/wesql/wesql
WeSQL is an innovative MySQL distribution that adopts a compute-storage separation architecture, with storage backed by S3 (and S3-compatible systems). It can run on any cloud, ensuring no vendor lock-in.
A Web Component to expand or collapse all details elements | Go Make Things
https://gomakethings.com/a-web-component-to-expand-or-collapse-all-details-elements/
Today, I wanted to share a little Web Component I made for expanding or collapsing all of the <details> elements on a page.
Redis Inc seeks control over future of Rust redis-rs client library, amid talk of trademark concerns • DEVCLASS
https://devclass.com/2024/11/27/redis-inc-seeks-control-over-future-of-rust-redis-rs-client-library-amid-talk-of-trademark-threat/
Redis inc, whose core product is the formerly open source Redis in-memory database, has prompted further unease in the community by approaching the maintainers of the most popular Rust client library for Redis with the intent either to control or to fork it.
Egoless Engineering
https://egoless.engineering/
It shouldn’t be a radical act because results are better if we can cooperate. And life is better without cult leaders.
How do we tear down parochialism and ego?
Regular Restarts Are Good, Actually
https://matt.blwt.io/post/regular-restarts-are-good-actually/
By enforcing the lack of local state, we can ensure that state lives somewhere more appropriate - a queue, a database, an object store and so on. This makes coordination significantly easier - shared-nothing services can be thrown away, scaled up and down without having to worry about state.