DoneHub

The most common problem with letting an AI coding assistant write code directly is that it starts coding the moment it gets a requirement — without considering edge cases, without writing tests, and halfway through it drifts from the original spec. When multiple features are being developed in parallel, code gets tangled on the same branch and rollback becomes a headache. Superpowers is a workflow system that uses Skills to make AI coding assistants follow a disciplined engineering process, built by Jesse Vincent (Perl veteran and one of Markdown’s co-creators). Its core idea: make the AI plan first, test first, implement, then review — work like a disciplined engineer, not an intern racing to ship.

In real-world LLM engineering, the core challenge of multi-agent systems isn’t making a single Agent smarter — it’s making multiple Agents collaborate efficiently while keeping the system controllable. When tasks scale from single-turn conversations to scenarios requiring parallel processing of dozens of subtasks, a system left to its own devices will almost inevitably sink into context overflow, task conflicts, or runaway token consumption. This article breaks down a battle-tested multi-agent architecture design, covering task decomposition, subagent spawning, state management, and concurrency control.

Background

The most frequently encountered engineering problem in Agent development is running out of context window. A 128K or even 200K window looks generous on paper, but tokens are billed by volume; running a 200K context round costs a few cents, and a few hundred rounds per day drives costs up fast. The longer the context, the higher the time-to-first-token latency, and user experience drops off a cliff. More critically, the more information you pack in, the more the model loses focus; key instructions get drowned in the noise of conversation history. Context compression isn’t a question of whether to do it; it’s a question of how to do it well.

This article breaks down the complete engineering solution for Agent context compression. It’s not just summarization; it’s a long-task state management system.

Read more »

Background

Building an Agent application inevitably raises a protocol design question: which real-time communication protocol should connect your frontend and backend? Two mainstream options exist: SSE (Server-Sent Events) and WebSocket. In practice, many teams start with WebSocket, run it for a while, discover the connection management complexity and operational overhead, and end up switching back to SSE. This doesn’t mean WebSocket is bad; the two protocols have distinctly different fitness levels for the Agent use case.

This article analyzes the choice from three angles: protocol mechanics, Agent communication patterns, and engineering practice.

Background

ChatGPT broke through in 2023, the Agent concept landed in 2024, and AI applications went mainstream in 2025. The AI toolkit for Java developers matured rapidly during this period. Spring AI 1.0 GA shipped in May 2025, and after nearly a year of iteration, it’s become the de facto standard for enterprise Java AI applications. This article covers Spring AI comprehensively: why it exists, how the architecture evolved, how it compares to LangChain4J, and how to use it in practice.

Read more »

Why SDD Took Off

In the second half of 2025, two hot projects appeared on GitHub almost simultaneously, both built around the same concept: SDD (Specification-Driven Development).

SDD isn’t new—the concept dates back to around 2010, but it never caught on. What changed in 2025 is that AI coding assistants finally became usable enough. Specifications used to be written for humans; now they’re written so AI can understand requirements and generate code. That shift turned SDD from a nice-to-have methodology into a practical necessity.

Read more »

Building a product solo, the worst thing isn’t the technical challenges — it’s realizing you’re simultaneously missing a product manager, an architect, and a marketing expert. Agency-Agents is an open-source repo that packages 200+ professional roles into Agent files you can import directly into Claude Code, letting indie developers tap into domain-specific expertise on demand. This post covers the repo structure, how to invoke agents, and how to use them to collaborate on a complete project.

When people hear “intent recognition” these days, the first instinct is to throw it at a large language model. The user says something, the model figures out what they want, returns an intent label, done.

That works, and today’s models have no trouble understanding intent. But once you hit real traffic, this approach falls apart fast. The real challenge in intent recognition isn’t whether you can identify the intent — it’s finding the balance between accuracy, latency, and cost. Understanding why you can’t rely on LLMs alone, how each layer of a three-tier architecture works in practice, and the kind of problems that tutorials skip over but you’ll almost certainly hit after going live — let’s walk through all of that.

When you’re developing with Claude Code, three numbers are always lurking in the back of your mind: which model you’re currently running, how much context headroom is left, and how much money this session has burned through. These figures directly affect output quality and your wallet, but Claude Code’s default interface doesn’t show any of them. Starting from v1.0.71, Claude Code exposes a statusLine custom status bar interface — you can write a script to monitor all three in real time.