I’m seeing a lot of AI coding tools trying to figure out multi-agent UX. To me, delegating feels like the least interesting part of the problem…

Do AI agents ask good questions? We built “Collaborative Battleship” to find out—and discovered that weaker LMs + Bayesian inference can beat GPT-5 at 1% of the cost. Paper, code & demos: gabegrand.github.io/battleship Here's what we learned about building rational information-seeking agents... 🧵🔽

More detail including a code sample for trivially implementing linking in an agent on my blog: mbleigh.dev/posts/co... Links were powerful enough to build the entire web...I think they'll be critical for building the context for agents as well.

Discerning what is at the core, and how to communicate it with others, has taken years. This might be the closest I've come so far. Part 2 of The Interfaces With Which We Think is out now... Start at the intro: alexanderobenauer.com/think/ Start at Part 2: alexanderobenauer.com/think/2/

Recent developments like subagents and agent planning tools have got me thinking: what are the right abstractions for natural language programming? I wrote about how we're rediscovering structured programming but this time for prompts instead of code.

New post 🎉 Going back to my roots on writing about the inner workings of things, a breakdown of key-value databases and how you might make one from scratch: nan.fyi/database

An AI coding approach I've liked using, which I first used on this project: Vibe code the first version. Investigate the code for its shape, complexities, needs, failure points. Then scrap all that and engineer a new version.

Great analysis of spec-driven development tools and recommendations for how to make them more effective: more variety of workflows, smaller iteration cycles, and better spec review tools

Some thoughts on LLMs, Autopilot, and VibeCoding rahulpandita.me/blog/2025-10...

These new Windsurf codemaps look a lot like Project Copernicus from @kcieslak.io githubnext.com/projects/cop...

6/ That said, HRM and TRM are fascinating proof‑of‑concepts that show what’s possible with relatively small and efficient architectures. I'm still curious what the real‑world use case will look like. Maybe they could serve as reasoning or planning modules within a larger tool‑calling system.

We have 🤖 AI notetakers in meetings but continue to silo know-how every time we close terminals. Not just the how but also the why and what. Sign up for beta access to visr.sh: it's like as if Granola AI and #tmux had a kid.

Fun panel discussion on spec-based development with @kiro.dev team. Especially interested in upcoming features to ground the specs to verify that the work is done correctly

What, if anything, do LLMs change about interface design?

As autonomous agents tackle larger tasks over longer trajectories, we’ll need tools like Trailblazer to quickly walk us through how problems were solved so verification doesn’t take as long as solving it ourselve

Teaching LLMs to Plan: Logical Chain-of-Thought Instruction Tuning for Symbolic Planning arxiv.org/abs/2509.13351

My ideas are faster than my fingers so I've did some Figma prototyping and video editing to talk about some of my new ideas before they are actual coded reality youtu.be/2DRWUgK-RdA

Want to visualize the response format constraints on the LLM when working in a Jupyter notebook? Then you might be interested in my new project `litelines`. Litelines lets you visualize the selected path by the LLM. It supports a Pydantic schema as a response format, as well as regular expressions.

Sometimes you need to build the wrong thing to get in the right headspace to build the right thing

"Generative, Malleable, and Personal User Interfaces" by Haijun Xia (2025) www.youtube.com/watch?v=MbWg...

Advanced context continuity with Projects and the Claude Pruner bookmarklet whtwnd.com/austegard.co...

Need to rethink my gesture math and try some polarizing film, but basics of panning the canvas are in there.

Cursor limits me to 5 custom modes so I reserve those slots for coding-specific tasks and do all my broader design thinking in Claude Desktop instead. Interesting how small constraints in our tools quietly redirect our entire creative process.

Is there a name for the pattern where you try building the same thing (feature, project, ...) a bunch of times with different agents to get a sense of the implementation design space? I usually run things at least 2 or 3 times until I "feel" what is the way I want it to be built.

Software engineering is evolving into software research. AI can now recreate most known solutions, so human value shifts from "how to build it" to "what should we build next?" The future belongs to those who discover new problems worth solving

Love this analogy from the RepoAudit paper. LLMs with huge context windows are like putting all your code on a single PowerPoint slide and then projecting it onto a 1000-foot screen arxiv.org/abs/2501.18160

Don did a good job explaining this here dsyme.net/2025/08/27/o...

I've been thinking about hypermedia and hyperlinks might evolve with LLMs. aifoc.us/hypermedia/ It feels like there is a lot of opportunity how links work and the value they can provide people.

A bit more about the creative word search tools in Phraselette: The 'Reader' well lets you to mock a panel of readers to examine specific word choice.

Skills are the new currency: https://blog.davidhoang.com/2025/08/17/skills-are-the-new-currency/

working with AI makes me wish more than ever that we had first-class layered undo. git is just 1 layer, yall. editor undo is a layer on top. i want several more layers, eg 1 to scrub the chat and codebase in tandem. 1 to cherry-pick specific changes made by the agent. don't tell me to multi-repo!

This new prompt optimizer from OpenAI is an exciting development. You can give it a prompt that you've already written and it will suggest improvements to your prompt and explain its reasoning for the changes platform.openai.com/chat/edit?op...

"Making these tools available to the systems we build, and specifically to the AI agents we build, gives them more power and leverage. Not by encoding the way we think, but by encoding the things computer science has learned about the way the universe works."

Can LLMs reason by analogy like humans? We investigate this question in a new paper published in the Journal of Memory and Language (link below). This was a long-running but very rewarding project. Here are a few thoughts on our methodology and main findings. 1/9

Chat is a great modality for starting open-ended single-player explorations. Chat is a terrible modality for managing long-running, structured, or multi-player tasks.

Great insights into writing custom rules that work. "The effective approach is to make the AI itself a partner in refining them." "Analyze our recent conversation. Based on the guidance and corrections I provided, suggest improvements to my .vscode/copilot-instructions.md file."

I wrote up some thoughts about why we’re seeing a gap in AI tool use among different types of developers narphorium.com/blog/top-dow... 1/4

I've been trying to articulate why the fawning, complimentary responses from AI chatbots feel so insidious to me. I've finally figured out how to explain it. Wrote a long piece on how current model training and design choices threaten our critical thinking skills: maggieappleton.com/ai-enlighten...

Reality Proxy: Fluid Interactions with Real-World Objects in MR via Abstract Representations arxiv.org/abs/2507.17248

I do this too. After an AI agent writes a lot of code I start a chat with my refactoring prompt to make sure it’s using the right abstractions open.substack.com/pub/worksonm...

Transclusion for context engineering www.fuzzycomputer.com/posts/spectree

As a big Jupyter notebooks user I can’t wait for better AI agents experience like this

Excited to pore over this new book from Buddy Bindery. Thank you @alexanderobenauer.com for sharing your artistry with the world

Turning "drinking water" into an achievement that you brag about has to be one of the most millennial things ever

Really neat idea for combining the strengths of different models

Great idea! This is something which senior engineers often do in their heads but I’ve never seen tools visualize it like this

Natural Language Outlines for Code: Literate Programming in the LLM Era arxiv.org/abs/2408.04820

AI codegen is walking us backwards into literate programming. Instead of jumping directly to code, I now dump my half-baked ideas into md files in a "specs" folder and let the agent rip. Or write a comment describing the function I want and AI completes it. My code has better docs and tests.

okay, vague idea: integrating LLMs + block based programming overcomes the biggest limitation of block editors (looping control flow etc.) internally, generate python jupyter-like snippets, but user should only ever see outputs. Draw edges to describe dataflow (demo whipped up using @tldraw.com)

This was a great talk which has nerd sniped me into building a data labeling widget with @anywidget.dev