Developing Taste in Coding Agents: Applied Meta Neuro-Symbolic RL — Ahmad Awais, CommandCode

Well, hello there. Today I'm really, really excited to both launch and share with you what we have been working on for maybe over a year now. It's called CommandCode, a coding agent with taste. So, who am I? Um, I'm Ahmad Awais, creator of CommandCode, CEO and founder of Langbase.

I've been around this block for, I don't know, like 20 years, building one thing after another. I've written hundreds of open-source packages with millions of downloads. Maybe you like my Shades of Purple code theme; I love the color purple.

And I— I'm an engineer. At the end of the day, I write a lot of code. And I've been building in the LLM space for about 5 years now. And I think the one of the first tools that I actually ended up building was a coding agent.

And at the end of the day, like, I'm very technical. I got to contribute to the NASA Mars Ingenuity Helicopter mission. My code lives on Mars. So when I'm writing code, no matter what LLM or what coding agent I'm using, I want it to learn from me.

I want to— I want it to learn that how I am editing its code. I want it to understand my preferences and continuously adopt to that, you know, preference set and invisible architecture of choices that I have. And that is what I'm excited to demo today,right?

So, uh, the story actually begins in 2020 when Greg Brockman gives me access to GPT-3. And I tell him, like, one of the first things— this is like 3 years before ChatGPT and a year before, you know, GitHub Copilot— I tell him that I want to build something with GPT-3 that suggests the next line of code,right?

So let's jump into a demoright away,right? Let's— let's look at what this actually looks like, and then I'll probably explain, you know, how we ended up here. So on the left here you see, you know, Claude Code, and this is CommandCode,right?

This is what we are building. As you can see, it is continuously learning, taste is on. This is what we call it. And I've been building a lot of CLIs. As you know, like, you know, if you know anything about me, you know that I'm all about automation.

And I've been building a lot of, you know, CLIs over the course of my career. So let's build a CLI. And Command here actually knows how I built a CLI yesterday,right? Or before that. It kind of understands my preferences of building a CLI.

So let's give both of them this thing,right? Make me a CLI that can tell date and ISO format,right? So look at what is happening here. So one of the first things that happen here is, Command kind of picks up on my taste file.

And I'm going to share a little bit more about it, but you see what is happening here? And I'm going to probably, you know, enable all these settings. So let's give both of these coding agents, you know, a set that it's on.

And you can see what Command is doing. It's using TSUP, it's using TypeScript, and it's building an ASCII art, you know, banner. It's NPM linking. It's going to NPM link this particular CLI as well. And these are all the things that I kind of care about.

And while Claude has done something really good, it's very fast, but, eh, I don't know, man. This is not what I wanted. It's like a console log of this or that. Like, when I build a CLI, I don't want to build a CLI, you know, a CLI like this.

I want to build something like, you know, please use TypeScript. And I want TSUP,right? And what else? I want Commander because I like to, you know, have more control over my CLIs. And what else? I want a lower-cased version number

with hyphen v because I know, you know, Command does this hyphen capital V thing. Like, I have so many preferences here. And by this time, Command has already done what I wanted it to do. How about we actually jump into code and see, you know, what it has actually done?

Let's open this up into VS Code.

And this is what Command did for me,right? So it is using TSUP, it is using TypeScript, it knows PNPM, that I prefer PNPM. I completely forgot to tell that to Claude. And if we go into this particular CLI here, you can see what it is kind of doing,right?

Like, it is using hyphen v for version. It is not, like, hardcoding a package version in here. And one more thing it should have picked up is, like, I want all of these commands to be in separate directories called commands.

So there you go, the date command is here. So when I grow this CLI into, like, you know, tell me human date or whatnot, it is going to put all of these commands here. It's very, very easy to test that way.

I wonder if it is also using Vitesse. There you go. Because I prefer Vitesse for, you know, writing a lot of tests. And one of those things, you know, it is using 0.0.1 version. I like to start here instead of 1.0.0,right?

And that is probably not what, you know, Claude was doing on this side,right? If I were to open the same CLI that Claude built for me, you will see that, you know, 1.0.0. And it's like, again, not using Vitesse.

Like, every single preference that I have, it is probably not going to do that. And then again, this thing, everything is here. I don't want it like this. This is kind of, again, Claude knows. Claude is an amazing model, but it knows what to do.

And with Commandright now, we are also using Claude, but it's kind of like I have to steer it so much that I kind of feel like it should be learning from me. And by the way, it is quite transparent.

If you look at this, we have a CommandCode folder in here. And if you see in here, there's a taste file. And if you go inside of it, there's a, you know, CLI taste that it has picked up.

And these are all my preferences. I can assure you, none of this is written by me. So CommandCode is continuously learning from me, and it is creating a lot of these taste-like things. This is not spec, this is not skill.

It's like my intuition built into a Meta Neuro-Symbolic Model, an architecture model that is more deterministic, that kind of figures out. It's more like a regex of my preferences. And it figures out, like, this is what I want when I'm using and building, you know, with writing with AI code or whatnot.

So let's step back in. And let's take a step back. Why and how we got here,right? And I'm going to share. We are going to publish a paper about it as well. I'm going to share a little bit more about, like, where we are and how we are going to think about it, why this kind of matters, and what is the architecture behind all of this.

So again, I started in 2020. The first thing I built was a coding agent, and that led to so many things. I ended up building Langbase. And we raised $5 million from all these amazing people. In fact, the founder of GitHub led our round.

And, you know, founders of all these amazing companies kind of supported, you know, our mission here. And the idea that we were trying to fix was memory. And this memory was not RAG. It was like a serverless RAG store, which can reason over your data, reason over how to help you, and continuously learn.

And we saw a lot of things. Like, I think this is the biggest problem in AI. I think the best thing that AI has kind of learned from humans is that humans are lazy. And that is what AI is.

AI is lazy by default. It's very sloppy. If you ask for a, you know, horse on a staircase banister, this is kind of what you get. And then you have to, you know, prompt it again and again and again to get to this left side of things.

You know, this is sort of what you saw me do with Claude when I was trying to build that CLI,right? To fix this problem, we basically launched a bunch of primitives. So threads, workflows, memory, what have you. And our hope was that people will start building amazing agents.

And then we saw, you know, like, we are doing, like, I think 700 terabytes and 1.2 billion agent runs a month. So we saw major scale. But we saw another problem. We studied that problem. And you can go to stateofaiagents.com.

You can study all of our research into how people were building agents. This is all public, by the way. And we figured out, like, even agents were very, very sloppy. Like, you know, I'm like, I think, like, I use AI for everything except for when I am writing,right?

Because every time I build an agent to write, or every time I use an LLM to write something, this sort of slop I kind of get back,right? So we have a collaborative dev tool. Can you write me a fun headline for it?

And what I get back is, like, power of synergistic teamwork or whatnot. And this is my friend. I actually saw him do this. And he's like, "Oh God, no, please fix it." And it got even worse,right? To fix this, we tried this command.new.

We launched it as chai.new and rebranded to command.new in the last 5 months. This was an agent of agents. You would give it a prompt, like, "This is the kind of agent I want to build." It will provision and create all of the infrastructure for you.

And I shared a talk about it as well. In 5 months, we have seen 150,000 agents vibe-coded with it. But there's just something missing,right? Vibe-coding, I think, is better than slop, but it's not better than the rules and choices that I have made, that I have kind of built my career around,right?

So we started to fix this problem again. And this is sort of, again, this is my 5 years of learning is around this. I think by default, AI is sloppy. This is the default setting of almost every LLM.

They are trying to be correct. And they are trying to be correct as soon as possible. That, I think, doesn't really work with code. And then we get this vibe-coding thing where somebody does the context engineering. You know, everybody has a different name for it, you know?

Behind the scene, it's context engineering, memory, and a bunch of prompts. And, you know, most of the times, you don't really have a lot of control over it. And to seek that control, what a lot of developers do is they start writing these rules files, like claude.md, agents.md.

And rules are never enough. I often tell, I often joke about this, that our justice system sucks because our rules are not enough. And then we have to go with this human lawyer and a human, you know, judge and a jury of humans to figure out what to do in that particular situation,right?

So I feel like there should be something that is learning rules from us. And it should be learning our taste of writing code. And that is why I put this thing, taste, here. What does that look like? Let me, like, like, I think this should be something that is acquiring our taste.

So CommandCode, a coding agent with taste, or if I'm bold enough to say it, it's something that is a coding agent with an acquired taste. It learns what is your taste of writing code. And this is sort of what it looks like.

So I know this might be a very silly and bad example. I didn't want to put a lot of text here. But when I look at this code, which is AI generated, I'm like, "No, no, no. This is not good.

I want JavaScript object parameters. Anytime there are more than two parameters, I want that." But AI won't, you know, listen to me. LLMs won't know my preferences of this thing. So again, when I ask for, "Make me a sum.js function," this is again a very dumbed-down version of an example.

Claude Code won't do what I want it to do. And Command just naturally knows this is what I prefer because it has seen me go and edit AI code and fix it this way,right? And similarly, we kind of saw this happen when I asked to build a date CLI.

This is, you know, Claude basically started with, "Here's a console log." And I had to tell it, "No, I want PNPM. I want TSUP. I want TypeScript." And all of that fun stuff. Whereas Command just kind of knows that I prefer Commander.

I prefer all of those things that I just, you know, demoed earlier in this particular talk,right?

So to sum it up, I think when programmers talk about good code, they're not talking about code that is correct. They're talking about this invisible architecture of choices that they have made throughout the course of their career to make their code, you know, kind of like readable, maintainable, and humane, and more like, you know, you.

Which is, I think, what is stopping me to write a lot of code. I want to generate. My mission is like, "What if I could do a lot of things in one day? What if I can have, like, 1,000 pull requests merged to main?"

You know, and my review time would just go down by 90% or 99% if an LLM, if a coding agent was doing what I want it to do,right? If it is not just picking up some sloppy code from 2015 Stack Overflow and slapping it to, you know, every request I have.

And I don't have time to teach it all the rules. I can either write code, or I can teach it to write code. I cannot be the one who's, you know, telling it when I'm using Next.js or, "Oh, no, even though both of those are, you know, creating API route files, what is the difference when I'm in this project and that project?"

It should just learn that in this situation, this is the confidence level it has around the conflicts that, you know, that arise from different rules and different projects,right? So I don't think I can do that. Again, this excites the hell out of me.

I think this is the invisible architecture of choices that every programmer is making. And that is what we are trying to build here, you know, a Meta Neuro-Symbolic Reasoning space with reinforcement learning. This is a very dumbed-down version of how we have set this objective.

If you don't know, you know, Neuro-Symbolic architecture is a more deterministic and explainable architecture than transformers. Transformers are generative. They are very probabilistic,right? So what we are trying to do here is we are trying to, I think Claude and GPT are good enough.

They are really good. And you can use whatever LLM with CommandCode, but that LLM will be combined with your taste, which is built upon this Meta Neuro-Symbolic space. You can think of it like, you know, a regex of your, you know, choices and patterns,right?

And we have a KL divergence loop here, as you can see. Like, if you do end up doing something wrong, we want the LLM to, you know, correct you as well. It's this amazing continuous learning tool that is both learning from your explicit and your implicit feedback.

And then again, it is creating that Neuro-Symbolic space to enforce that invisible logic around your choices, the architecture that is in your head. It is in your brain. Like, "Oh, yeah, when I'm building, you know, a TypeScript project, this is the type of thing I do,"right?

That kind of thing. That can never really, like, your brain can never really translate that into a, you know, rules file. Otherwise, like, you won't be writing code. You will be writing a lot of rules files,right? And then again, at the end, to use the neural part, the LLM part, we have reflective context engineering, which is self-aware, which is continuously learning and adopting.

Like, "Oh, this guy used to use Miao for writing CLIs." And I don't know what happened, but two months ago, he switched to Commander. I'm talking about this guy, by the way. This literally happened,right? And I feel automatically update my rules, my learning from me, my taste that now Emmett prefers to use Commander over Miao.

I don't need to go and teach it. I should be writing code at, I don't know, God speed. And it should be learning all of this from me. And over time, we've believed that this will turn it into a skill of intuition that CommandCode will have, that you can share with your team.

Our mission is to build a huge ecosystem around this. Imagine if you could, if you really like a developer out there whose React, you know, code is amazing,right? I love what Tanner is doing at TannerStack with 10 Stack,right?

So what if I could have Tanner's taste when I'm writing React code? You can do that with CommandCode. What if, like, one of the things that I have been using it a lot for, like, my design engineer has a much better design skill than I do.

Whenever I'm writing any kind of front-end code, I actually borrow the design engineer taste I have, which is messy. Like, all those margins and paddings and amazing tiny little details in his taste that I don't need to now care about.

But my LLM in my CommandCode, my coding agent, kind of puts that LLM and that Meta Neuro-Symbolic design taste alongside my request. Like, "Build me a model that does this." But it does it with my design engineer's taste, which is unbelievable,right?

So this is where we are today. Today we are launching CommandCode. You can, you know, feel free to go to commandcode.ai, you know, check it out. This is the very beginning of all of it. I think large language models have captured the world's text, everything out there, all of the Stack Overflow and whatnot.

And I believe what we are building with taste models is the world's intuition,right? And their intentions,right? What do you intend to do? And how do you generally do it? What are the patterns? What is your taste? And that taste with your preferred LLM is, I think, the next frontier of coding,right?

Taste, I totally believe, is going to really, really speed up how we write code, really, really create that Neuro-Symbolic guardrails of your, you know, again, invisible architecture of choices that you have as a team, as a project, as a famous library, or, I don't know, maybe you are an enterprise who care about doing things in a particular way,right?

That is the kind of thing that you would be able to build taste around and share it with, you know, as an open-source taste, or share it with just your team. Like, for example, if you go sign up, again, this is very, very new.

This is potentially what it will look like,right? We've already kind of moved away from sharing all of this. And we are figuring out, I would love your help to figure out what is theright mix of having all of this meta learning, you know, be part of your projects.

Right now, it kind of ends up as more of a, you know, what should I say? A transparent Markdown file. But it could exist in any which way. It's a Meta Neuro-Symbolic space and a model that is continuously learning your preferences.

And we can dump that learning in any particular form. Right now, this is potentially what it looks like. You should be able to, you know, npx taste and install my CLI taste. And then you can use CommandCode. And the CLI that you will build will be very, very close to, you know, how I would build that CLI using your favorite LLMs.

So, yeah, that's pretty much it. As you can see, I am pretty excited. You know, our biggest gains that we have seen internally at Langbase are we have probably 10x'd the amount of code that we are merging in our main repository,right?

In our main branch,right? Which is generally, we joke about it. Like, when we disagree and commit to main, the amount of that happening has increased 10x. And I'm feeling a lot more confident when I'm reviewing a lot of code,right?

So our review time for any kind of coding pull requests has gone down significantly. And I can't wait to see, you know, what everybody out there builds with it. Again, we're very excited. We want that LLMs should continuously be learning from our taste of writing code.

And I would love to see, you know, what you build with CommandCode. That's pretty much it. Feel free to reach out. And maybe, you know, send me a tweet or post or whatever we call it these days. And I would love to see, you know, what everyone builds.

This is me, Ahmad Awais. Thanks for having me. Ciao. Peace.