Also, check out our launch tweet — likes and retweets appreciated 🙏.

After a year of building agents, we’ve hit upon a multi-agent abstraction that allowed us to top Claude Code in our evals.

So today, we’re open sourcing and releasing our framework so anyone can build on top of it.

• If you’re building a product with AI agents, this is for you!

• If you’re a developer looking for the best coding agent, this is also for you. Try tinkering with our custom agents to improve your day-to-day development!

In this example, we see an orchestrator agent spawning a scout (”Lewis & Clark”), which in turn spawns a file explorer (”Dora the File Explorer”). The orchestrator continues on to spawn a planner (”Peter Plan”).

We built this framework to solve our own problem.

After a year developing a coding agent, our codebase had grown unwieldy with many scattered LLM calls and tools that were defined in pieces, with if statements sprinkled throughout the core agent loop implementing special cases.

We refactored our sprawling spaghetti code and iterated on a framework that could replicate all the capabilities of Codebuff. We ended up with something shockingly simple and powerful (never has a refactor gone so well!). Codebuff has been condensed into half-a-dozen agents, each defined by a simple Typescript file.

Delete your spaghetti code. Use our agent framework!

We are launching the open source Codebuff Agent SDK, so you too can delete your spaghetti code and make agents that compete with the best!

We already have Vly.ai (YC F24) building on top of our framework to make a Lovable competitor. Victor says it makes their agent “way smarter [and] better”. Danny Hsu (YC F24) building Aspects Studio says that “Codebuff’s agent SDK captured exactly how my agentic flows were set up and provides tooling for all of the hard parts.”

Agents as the composable unit

The core idea in our framework is that the agent is the composable unit, not individual LLM calls. An agent is simply a model with prompts and tools that is allowed to take multiple steps.

Each agent has a list of which other agents it is allowed to spawn. When run, an agent can dynamically spawn these subagents whenever it likes in order to accomplish a given task, frequently in parallel!

More on the framework below — but we’ve found it to be a highly configurable agent runner that solves the tricky parts of running agents. It's like the Claude Code SDK, but with more power: you can choose your model, customize prompts, and seamlessly mix in programmatic code to steer your agent.

Let’s see some examples that demonstrate what makes our framework easy to use and powerful.

Example 1: File Explorer

Ahh… that feeling when you deleted all your spaghetti code and your agents are simple again.

This file explorer agent is simply defined. The heart of it is the “instructionsPrompt” which can describe multiple steps for the agent to carry out.

Instead of always relying on the system prompt, our framework gets much higher rates of success by injecting instructions as a “user” role message at the bottom of the message history.

Example 2: Git Committer

To get even more control, you can mix in code! Our framework uniquely allows you to intersperse LLM generation with programmatic code using JavaScript generators (the syntax might look foreign, but it's surprisingly simple!).

The handleSteps generator yields tool calls or instructions to “step” the LLM. It’s a superpower for agent workflows!

In this example, we always run git diff first, and then yield ‘STEP’ to run one LLM call that reads files chosen by the agent. Finally we use ‘STEP_ALL’ to let the agent take as many steps as it wants to generate the commit.

Compare this code to the equivalent code in another framework or by rolling your own. It’s literally 10x less code. Moreover, everything that defines the agent can be co-located in one file.

Example 3: The Orchestrator Pattern

One of the most exciting results from iterating with our framework is we came up with what we think is the next breakthrough architecture for coding agents — or even agents generally!

Actual code from our production coding agent!

We use an orchestrator agent with no tools at all, except for one tool to spawn agents. Everything that it does must be done by delegating to subagents.

The agents that it spawns are all crafted for specific purposes and use different models. Each agent defines a prompt used to inform the orchestrator of when it should be spawned.

And then… the orchestrator makes all the decisions of when to spawn which agent to accomplish the given task.

The magical part is that with this setup, we get for free near-perfect context management.

That’s because spawned agents don’t add their message history to the orchestrator’s, cluttering it up with tool results. Instead, they contribute just their final output, which can be whatever they think is important.

(Unlike Claude Code’s subagents, we have several options for defining an agent’s output, via the last assistant message, a structured output schema, or even a programmatic handler!).

This means that the orchestrator agent’s context window grows very slowly and includes all the essential information about what the user asked and what actions have been taken thus far!

I’m very excited to see what agents our community creates that can plug right into the orchestrator. Modular agents are the new MCP!

Get the SDK

Using our npm package, you can define agents, use any model on OpenRouter, and run them programmatically. You can even define your own custom tools, and (more on this soon!) publish agents and spawn other people’s agents!

All you need is a Codebuff API Key to get started (click here to get one in 10 seconds). Then simply call run() on the SDK client:

Get the Codebuff Agents SDK here. Learn more about our agent framework here.

Framework results

As a result of our migration to this framework, we have improved our code quality leaps and bounds, sped up our dev cycle time, made our code more reliable and testable, and increased our eval scores.

On our internal benchmark of 175+ distinct implementation tasks across open source codebases, we now achieve a 61% score compared to Claude Code's 53%.

In our BuffBench eval, we have a prompting agent pretend to be the user with the goal of implementing a hidden spec. Each spec is derived from a real git commit, and a judge agent compares the coding agent’s result with the real git diff to judge correctness, code quality, and task efficiency.

But even more than a near-term increase in evals, our eyes have been opened to what’s possible. Composable agents are coming, whether we build it or someone else does. And it’s going to be open source (whether we build it or someone else does).

Thanks for reading, now go check out our newly open source repo! We put some effort into the README!

(🎶 Also, check out the song version of this article, entitled “Delete your spaghetti code”)

We’ll be launching every day this week on social media and Discord. At the end of the week, we’ll post one more Substack article to wrap things up.

Cheers and happy coding!

—James

Big thanks to Danny for the video-editing and graphics, and Akio for thoughtful feedback reviewing a draft.

I’m excited announce our custom model for file-picking, which significantly improves on our previous solution!

When you enter a prompt into Codebuff, it searches through your entire codebase to pick about a dozen files relevant to your prompt in the first 2 seconds.

The new model we are shipping to do this task does twice as well at matching our golden dataset as before! That means we’re a big step closer to picking the ideal set of files right off the bat!

This cements Codebuff’s speed advantage as well as its quality advantage.

It’s a superpower to start off with all the relevant context, because it means the LLM can make an informed decision about how to act on your prompt. Context is everything!

We have even more ideas to improve on this aspect of Codebuff. The product will only get better from here.

That concludes our first-ever Codebuff Launch Week! We showed off an awesome set of improvements, including:

• Simple usage-based pricing

• --max mode with a hybrid Gemini / Sonnet agent — best coding agent ever?

• --lite mode using Gemini 2.5 Flash Thinking

• The “init” command to set up Codebuff and manage development processes

• A custom model for file-picking

I’m super proud of our team of 3-and-a-contractor. We’ve all been working night and day to push forward the state of the art for coding agents.

We’ll have to do this again! The launch week format is a great way to share our progress (while making a lot of noise!).

It’s going to be hard to stop Codebuff domination now!

Cheers,
James

Open codebuff, type “init”, and hit enter!

(You can also run codebuff --init for the same effect!)

This command will send Codebuff off to examine your project and generate two files:

• knowledge.md — the classic file to store project knowledge, preferences, and common commands in an unstructured format

• codebuff.json — codebuff’s new config file! This can contain background processes that codebuff should manage

It’s super useful to have Codebuff create these automatically. It works even if you already have a knowledge.md file.

Over time, we can tweak this generation to incorporate best practices for Codebuff!

Knowledge files

For those new to knowledge files (check out our docs!), this is a great place to note down any weird bits about your project so codebuff doesn’t get confused. These files will always be added to context (if in the root level of your project).

Additionally, Codebuff will automatically update this file when you correct it with some info or preference it deems important enough to save.

Codebuff.json (new!)

This is the most exciting new piece in today’s release!

You can use this file to specify startup processes, which codebuff will manage for you.

Codebuff will automatically:

• Start these processes & kill them when you exit

• Receive new logs from these processes, which can help debug errors!

Instead of opening multiple terminal windows and switching back and forth, now you can just have codebuff run them all.

And, it’s an absolute superpower for the coding agent to be able to monitor the output of all these processes and incorporate any insights from them to help you solve problems.

I’m incredibly excited by this release, which takes a step toward our vision of coding agents managing local development for you.

Try it out for yourself, and let us know how it goes!

That’s all for today. But do check back tomorrow!

We’ve saved a real doozy for the 5th and final day of Codebuff Launch Week.

Cheers,
James

Today, we have another exciting update for those interested in using credits efficiently: an overhauled codebuff --lite mode!

Compared to normal Codebuff, --lite mode is roughly:

• 1/5 the cost

• 4x the speed

Which is pretty amazing when you consider Flash is able to act like a full coding agent. It fluently uses all the tools we provide and is good for easy-to-medium coding tasks.

It seems like Flash is better at adhering to the exact format of tool calls than Gemini 2.5 Pro, which is a surprise! Google still has some bugs to work out there.

“Gemini Code”

Codebuff improves on other coding agents by selecting all the best models and using them in the most appropriate way.

We do this for you, so you don’t need to keep up with the endless releases from different labs, each one-upping each other.

These days, however, it seems we are choosing more and more Gemini models. One might say Codebuff is the “Claude Code of Gemini”, or Gemini Code!

We’ve got two more exciting releases planned for the rest of launch week.

Thanks for reading, and stay tuned!

Cheers,
James

Today is one of the releases I’m most excited about! We’ve overhauled the Max mode into a state of the art agent that does more thinking at every step.

Simply run codebuff --max, and prompt away:

We’ve spiced up this mode to use a really interesting combination of models:

• Gemini 2.5 Pro for its planning abilities

• Claude Sonnet 3.6 for its reliable tool calling

The resulting hybrid thus can craft brilliant plans and execute on them. It seems to work really well in early tests.

In addition, max mode also will read more files. This plays to Gemini’s strengths as it remain coherent at much larger context windows than other models:

For example, Gemini 2.5 Pro reach 90% on this benchmark for 120k tokens, where others hover around 40-60%.

Give it a shot, and see how you like it! It is a bit more expensive, however, it’s much cheaper than using o3 would be, for what appears to be much better results.

Codebuff —max may be the best coding agent on the market today. We will look into some benchmarks to prove it.

Thanks for reading. We still have 3 more days of launches this week, get hyped!

Cheers,

James

Welcome to the first-ever Codebuff launch week! I’m super excited to ship something awesome everyday.

Usage-based Pricing

Today, we’re announcing pay-as-you-go pricing!

Instead of locking yourself into another monthly subscription, you can just buy credits and use them incrementally. That means you can top up with just $5 at a time, or optionally enable auto-top up.

Usage-based pricing was a top user request that we heard on a near-daily basis. Users want to control their spend and not waste money on credits they won’t use.

Additionally, you’ll continue to get free monthly credits. New accounts get 500 credits ($5 value) per month for free forever. Referring new users will get you 250 credits ($2.50 value) per month each! And all previous referral credits have been maintained. Free credits reset each month.

However, credits you purchase will never expire. You can sleep easy! Note that Codebuff passes on the actual cost of the API’s, plus a small margin.

Bonus: New website, checkpoints, choose your --model, browser logs

We shipped quite a few things since our last newsletter! I’ll highlight some here.

Snazzy new website

Check it out, it’s awesome. The new logo is a cute terminal character.

And if you scroll down, the competitors section is pure gold!

Checkpoints

Ever wish you could go back and tweak your prompt? Now you can!

Charles, our first hire, has built out a full checkpoint system so you can always undo changes and reset the conversation back to an earlier point.

Choose your own --model

You can start codebuff with your favorite model by providing it as a command line arg. This model will be used as the main coding agent!

While it’s fun to experiment with different main models, we do recommend sticking to the more well-tested modes: normal codebuff without any arguments, --lite, and --max.

Reading browser logs

Are you vibe-coding a website? Ever hit upon a console error that you had to copy and paste into Coebuff? No more!

Now Codebuff can check for console logs and errors and fix issues for you. This can even be used to debug issues if Codebuff inserts console.log() statements and checks the results.

This tool helps close the loop to allow Codebuff to do even more of your web development.

That’s all for now — see you again tomorrow for Day 2 of our Launch Week!

Cheers,

James

P.S. We’re hiring! Send an email to jobs@codebuff.com to apply.

Here to share a few fresh updates from our corner of the terminal!

Big Performance on Big Codebases

Codebuff now runs like a dream on large projects (yes, even the VSCode codebase!), and you’re even less likely to hit the context window limit during marathon sessions.

We’re so confident about this that we issued an open challenge a couple of weeks ago to give $100 to anyone who prefers another coding agent to Codebuff on large codebases. Many challengers knocked on our door, but only one person has able to claim it so far. Wanna try your luck? Email us at hi@codebuff.com if you found a situation where other coding agents did a better job on your codebase, and include screenshots to explain! Submissions are valid until March 14th 2025.

Be warned, you may just fall in love with the product, like this user:

Upcoming change: 500 credits per month for new accounts

New users will soon receive only 500 free credits (instead of the current 1,000) per month. We’ll be updating the system this week, so please sign up asap to lock your 1,000 credits in!

Install codebuff:

npm i -g codebuff

And start it up in a project directory of your choosing:

codebuff

We’ll start the login process and set you up with 1,000 credits! And of course, you can refer your friends to receive an extra 500 credits each.

New Features

Upgraded File Editing

Our file editing just got a huge boost! We’ve reworked it with a shiny new speculative decoding model (huge thanks to Relace AI), which means lightning-fast, more accurate rewrites. We hope you’ve been noticing the extra reliability recently. And of course, let us know if issues crop up when Codebuff edits your files.

Planning

This is the a big one: you can now tell Codebuff to “plan” your next feature or refactor and it’ll whip up a detailed markdown blueprint (e.g. `user-stats-page-plan.md`) with a thoughtful plan and a few follow-up questions for you to help create alignment. You can tweak it manually (it’s just a markdown file after all) or tell Codebuff how to further refine it. When that looks good to you, just tell Codebuff to build it out. It will continue to reference the plan as it works, so it doesn’t lose focus and wander. It makes a world of difference and can help you code multi-hundred line changes with confidence.

Browser Actions

Introducing a secret alpha: browser actions. When you ask it to, Codebuff can now launch Chrome to actually see your frontend in action! It automatically navigates, snaps screenshots, and pulls browser logs from the website. Here’s a quick demo:

For more complex actions (like clicking, dragging), you can perform the actions manually and then ask Codebuff to capture and analyze a screenshot. This feature is still in alpha, so it's a bit rough. Please let us know what bugs you find!

Feedback pls

We want to know how Codebuff is working for you! We’re particularly excited about planning, we think you’ll really like it :)

If something seems off or an edit goes sideways, ping us on Discord (or over email at support@codebuff.com). Codebuff also recently started storing your conversations on the client-side, so you can also share it with us to help troubleshoot.

We put together a little survey, could you take a minute to fill it out? Thanks for being part of the journey!

Happy coding,

James and Brandon

o3-mini is live in Codebuff!

We launched our o3-mini integration on Friday, a few hours after it was first available. You can trigger it by simply asking Codebuff to do something complex.

Codebuff will then enter a “deep thinking” mode where it triggers o3-mini with effort level “high”.

We think this is the best way to leverage reasoning models: as architects that plan the best solution. We expect this combination of o3-mini + Sonnet 3.5 to top the LLM leaderboards shortly.

Community GitHub Repo

We’ve just launched the community-codebuff repo on GitHub (give us star!), featuring:

1. Starter templates for new Codebuff projects

2. Community showcase projects

3. Knowledge! Organized in knowledge files on different topics

Starter templates

First, you can now create new projects from our set of starter templates! Each starter template is configured in proper Codebuff form with a knowledge file.

For example, to create a NextJS project, run the following:

# Creates a new nextjs project in directory my-app.
codebuff --create nextjs <my-app> 

You can choose from a variety of templates including nextjs, vite, remix, convex, node-cli, python-cli, and chrome-extension, with more to come!

Showcase

Secondly, after so many of you have wrote in with projects of your own creation, we decided to try to collect them into a showcase.

We have a minecraft clone up, and thanks to our users narthur and Lachlan for their contributions as well! You can use the --create command to clone any of these projects and try them out locally!

Knowledge

Finally, we want to collect and share knowledge for the Codebuff agent. Upload knowledge files that describe a technology you are using — for example, a component library you want it to use, or how to optimize react re-renders. We hope to eventually allow Codebuff to read from this knowledge via a tool call so it can access it when needed.

Take advantage of this open source content to improve your own use of Codebuff. And then, give back to the community by contributing to the Codebuff community repo with your own starter templates, showcase projects, and knowledge files.

Performance Leap: New Model Integrations 🚀

We’re excited to announce two major modes that make Codebuff outputs higher quality or more cost-effective:

1. codebuff --lite: For more efficient code generation and still surprisingly good performance.

   • We’re using DeepSeek’s first reasoning model, R1, as the main agent as well as DeepSeek V3 for finding files.

   • It can often match the performance of o3-mini and Sonnet 3.5, but at one-tenth the cost—enough to run a full demo for just $0.02 in credits.

2. codebuff --max: For the highest quality code generation, using better models to find files and plan changes.

   • Finds files with Sonnet instead of Haiku for an improved ability to get the right context

   • When o3 comes out, we’ll use it for planning instead of o3-mini.

We’ve also fixed a bug that prevented Codebuff from finding all your files, so it should now run more smoothly than ever!

Quality of Life Improvements

We’ve introduced several updates to enhance customization and usability:

• Tab Completion

  Hit the “tab” key to quickly autocomplete folders/files, just like in a standard terminal. It also works for names of classes and functions in your codebase.

• (Finally!) Add new lines within Codebuff

  Press the space bar twice to insert two new lines (a workaround for archaic terminal limitations).

• Global Rules via Knowledge Files

  You can now set universal rules across all Codebuff projects by placing a knowledge.md (or .knowledge.md) file in your home directory. For instance, add a single line to enforce Poetry usage in all Python projects—no extra setup required.

  This feature is still in alpha, so let us know if it’s helpful in your workflow!

• Code Search!

  Codebuff can now search your codebase and get back file results. The agent crafts a regular expression that is executed by the blazing fast rust library ripgrep. This makes Codebuff even better as a junior software engineer that does whatever you tell it.

• Bug fixes

  • Codebuff is much less likely to run disruptive commands like git push, run a dangerous script, or install a package globally without permission.

  • We’ve squashed a pesky cursor bug that forced terminal restarts.

  • Ctrl-C now kills the currently running terminal process.

  • Overflowing the context window should be rarer.

  • …and much more

You should now have a much smoother experience overall using Codebuff.

Nosu Hackathon

We also sponsored a hackathon hosted by Nosu. A huge shoutout to the winners Hannah Rauch, Phil-Ho Combatir, noor sahel, and Chan Dinh.

They made Project Paemon: a fun questionnaire that lets you hatch your own “pæmon” based on your answers. Be sure to check it out, we hope it sparks new ideas for projects you’ll share with the community!

Stay tuned!

We have many more exciting updates in the works. Codebuff is now rivaling and in some cases exceeding the best other codegen products on the market. We’re coming for you, Cursor!

Our vision is right: Developers want a simple interface to direct an agent to do work quickly and locally.

We accomplish this with more intelligence than anyone else: a fleet of LLM’s, including up to 7 different models today, that solve each subproblem for you. We are well on our way to the world’s best coding agent!

BTW, we’re hiring

If you’re intense about wanting to help us build the best coding agent (or know someone who is!), send your resume/LinkedIn to jobs@codebuff.com.

Thanks for reading! We’re always interested in your feedback. Email us at founders@codebuff.com.

Until next time,

James + Brandon

Big news - we've just leveled up AI-driven coding with something we're super excited about: agentic workflows. Imagine having an AI that doesn't just spit out code once, but keeps refining and improving it until it's chef's kiss perfect. That's what we've built.

Agentic Workflows

So what exactly are agentic workflows? Think of it like having two AI teammates working together to crush complex coding challenges. We've created a dynamic duo:

• Coding Agent: Generates code based on the reviewer agent’s demands.

• Reviewer Agent: Evaluates the coding agent’s output and reprompts it as necessary. Basically, it runs the agent in a loop on your behalf.

You can start using Codebuff's agentic workflows today. To trigger it, use phrases like “keep going until <x>” or “work on <y> until you’re satisfied”. Feeding language like this into Codebuff spins up its Reviewer agent.

So why did we even build agentic workflows? We had originally built Codebuff with only the coding agent, but wanted to burn more tokens make a few more things possible:

• Execute open-ended instructions like "Polish up this feature to make it more user friendly". Agentic workflows enable this by dividing high-level tasks into bite-sized, sequential steps for the coding agent.

• Produce higher quality code by having the coding agent pass through files multiple times.

The original coding agent is good at spitting out code in a single step, but we needed more. To get closer to enabling truly autonomous feature-building using today's technology, we needed agentic workflows.

Side note — the new reviewer agent might seem like a demanding master, but does a damn good job managing the coding agent. Hopefully this doesn’t have real world parallels.

Minecraft in the Browser

We recently decided to put Codebuff to the ultimate test:

Could it build a browser version of Minecraft using only open-ended instructions?

We started off the exercise by giving it a few open-ended prompts. We then gave a super open-ended prompt:

"Please develop the game to be more fleshed out with more stuff and interaction and instructions. Go until you are satisfied."

This spun up the Reviewer agent. The Reviewer and Coding agents then went back-and-forth for a little while, all by themselves. Here's an interesting example of what the Reviewer agent told the Coding agent during execution:

"CONTINUE. Still need to add particle effects when breaking blocks to complete the user's request for a more polished game. This will provide satisfying visual feedback when destroying blocks."

It’s funny, we found agentic workflows work well when it resembles how actual product teams collaborate. You might even notice that when starting an agentic workflow, the "product manager" agent creates a product design review.

Back to Minecraft. The reviewer and coding agent continued to collaborate until the reviewer agent was satisfied. With just our single prompt, the reviewer agent coached the coding agent to generate:

• Hover effects to preview block placements.

• Particle effects for breaking blocks.

• An interactive overlay for block selection.

Here's the final output of what these dynamic duos created:

We put this in front of about a dozen people, who each added a new feature/idea, and ended up with this by the end:

Customer Love

Other than the agentic workflows, we also wanted to share what a customer told us recently. Let us know if you have similar or differing feedback! He said:

"Codebuff can take an idea from 0 to 1 very quickly with structure and MVP working features. I tried a few different projects out, and found the best use case was rapidly iterating on the UI."

We hear this a lot. People love Codebuff for generating tons of code quickly and speeding up the iteration process. It creates initial scaffolding for a new feature, test, or codebase within minutes.

However, we've also heard from developers that they still need to review the code quite a bit after prompting Codebuff. The same customer mentioned:

"Codebuff is a great tool, but do not let it replace basic problem solving. The best use case is for large output and moving fast. You should always check out a problem before blindly asking for a solution."

It’s something we’ve been mulling over as well. Even though Codebuff is likely the best in class for code quality today, we’ve still got a ways to go.

It's one of the reasons why we're excited to get your feedback on agentic workflows. The new reviewer agent double-checks the coding agent's output. We think you’ll see a noticeable improvement in code quality because of it.

2 Minute Agentic Workflow Tutorial

Quick shill: for every person you refer, you’ll both earn 500 credits per month (for the time being).

Ok now for the tutorial. Hopefully the Minecraft example hinted at how to run agentic workflows, but here's what you do:

Run the following in your terminal (make sure to hit “enter” after each command before moving on):

npm i -g codebuff
mkdir minecraft-codebuff && cd minecraft-codebuff
codebuff

Once it starts up, log in to claim your credits:

login # this generates a link to log you in and give you more credits

Now you can tell it “generate a basic minecraft clone that runs in my browser that lets me move around in the world, explore it, and mine blocks. keep going until it's very recognizable as a minecraft game”

Then, watch the magic happen. Beware, this will use a lot of credits! We’re building features around managing credit spend for these long agentic tasks, but we couldn’t wait for those to be done before showing this to you!

Towards our Autonomous Coding Future

We've always wondered about the day when development teams can offload day-to-day feature creation tasks. Today, engineers copy code from AI. In the future, AI will build entire features. Software developers will only have to make decisions on relevant feature selection and product strategy based on domain knowledge.

Codebuff’s new agentic workflow feature gets us one step to that longer-term reality. Today, Codebuff is still the only codegen tool that:

• Chooses which files to read and edit automatically, by default — other AI coding assistants require you to specify which files to edit.

• Harnesses your existing tools, scripts, and packages without needing explicit approvals — Codebuff installs packages, runs terminal commands, executes tests, etc. Whatever awk/grep/pip install stuff you used to do, Codebuff now does it for you instead.

• Runs in any development environment — There’s no lock-in. You can bring your IDE: VSCode, Cursor, Vim, Emacs, Replit, or plain text editor (if you’re a monster).

And we’re cementing our lead even further by adding agentic workflows to the list! Please try it out and let us know what you think.

Alright that's it for this newsletter. Thanks for reading! Until next time.

- James & Brandon

Hello everyone! If you are reading this, you are one of our very first users. Whether you just joined after our Hacker News launch or used Manicode from the start, we want to welcome you and thank you for taking the leap to try us out.

I’m excited to say that we’re growing extremely rapidly. The day after our Hacker News launch was our biggest yet, with >700 million tokens burned! That would rank us as #2 on OpenRouter by token usage — watch out Cline!

Life after Jim Manico

Unfortunately, we had to give up the Manicode name (RIP the maniverse). After our Product Hunt launch, Jim Manico made us aware of his existence and his software education company, also named Manicode. Our lawyers told us that he has legal precedent, so we would have to change our name.

You can find the entire dramatic story on this market on Manifold about what Manicode would be renamed to. We got 57 candidate names (and even more in a Notion doc)! Codream, Heycode, Yocode, and Dreamcode were close contenders, but we went with Codebuff in the end. Let us know in the comments what you think of the new name!

Customer case study

We get new reports daily in our Discord (join us!) of Codebuff doing something awesome.

Here’s a standout example posted this morning, from Stefan. When you can spend $50 to save 4 days of engineering, that’s a Codebuff win!

Codebuff improvements 🔥

The product has improved exponentially in the last couple weeks. This is no exaggeration!

Codebuff now uses the new Claude Sonnet 3.5. The upgraded Sonnet 3.5 has achieved 49% on SWE-Bench, improving on the previous Sonnet’s score of 33%. The previous world-record was 45%, which shows that Codebuff’s strategy of leveraging off-the-shelf models is working well compared to other startups training their own custom models.

The new Sonnet 3.5 is just nicer to chat with and use. It makes better edits and writes cleaner code. It's way better at refactoring large sections without introducing bugs and just feels smarter in general. Congrats to the Anthropic team on shipping this!

We’ve implemented prompt caching and switched the LLM behind picking the relevant files in a codebase to the much-awaited Haiku 3.5. We’re now doing the same work of file picking in 1/3 the cost with lower latency. I even had a market on when Haiku would be released. All files and edits are cached, which drastically reduces the token costs. Codebuff credits should go almost 10 times further with these changes!

Earlier this year, Cursor shipped a special speculative decoding model that can edit files at a thousand tokens per second. Last week, OpenAI released “Predictive Outputs” for their models, which uses speculative decoding and speeds up model outputs (though not quite to that level). We now use GPT-4o-mini to rewrite files when the deterministic edits can’t be applied, which should prevent Codebuff from deleting your entire file when an edit fails :P (We are also in talks with some startups like Relace.ai, which will help us compete head-to-head with Cursor’s speculative decoding models.)

We now have a website, where you can upgrade your plan, read testimonials and the FAQ, monitor your usage, or refer more people.

What’s next

Codebuff is unusual in terms of how few approvals it asks for. It will literally just run any command it wants in your terminal with no guardrails.

We heard some feedback on this, especially after our Hacker News launch, and so we’re going to make some adjustments, in order to help our users feel safer and more confide—

—Psych!

No, instead of that, we’re doubling down on this unique angle of a fully capable agent in your terminal.

We’re planning to invest more heavily in autonomous operation, including helping Codebuff to automatically fix type errors, linting errors, and failing tests.

Imagine this. You brain dump a description of a new feature and tell Codebuff to implement it while using tests and the type checker to verify progress.

You further say, “keep working on the feature until you have something good” and step out to make coffee.

When you check back—Bam! It’s produced a really strong first stab at your feature with some creative ideas and an implementation you hadn’t thought of, saving you days of work.

This is the future, and it’s coming soon to Codebuff.

Tell your friends!

For every person you refer, you’ll both earn 500 credits per month, forever-ish*. This is an insane deal that only works because of sweet VC cash. What are you waiting for?

* Probably not actually forever, but we’ll see.

And so concludes the first-ever newsletter for Codebuff. Thanks for reading! Until next time.

Keep on burning the midnight tokens.

—James