AI Engineer Code 2025
Developing Taste in Coding Agents: Applied Meta Neuro-Symbolic RL — Ahmad Awais, Command Code
Read the talk
Developing Taste in Coding Agents
A date CLI exposes the gap between correct code and code you would choose to write. Command Code attempts to close that gap by learning from edits, preferences, and changing project context.
From a talk by Ahmad Awais
Before you start: Familiarity with JavaScript or TypeScript, command-line tools, and coding agents will help with the examples.
Can an agent learn how you would write it?
When a coding agent writes working code that you immediately restructure, what should it learn from the edit? The next request should not require you to explain the same preferences again. That is the problem behind Command Code, which Ahmad Awais introduces after roughly a year of development: an agent intended to learn how its programmer changes generated code and adapt to the choices behind those changes.
Awais approaches the problem as Command Code’s creator and Langbase’s founder and CEO, with a background spanning open-source packages, the Shades of Purple editor theme, and an open-source contribution to NASA’s Mars Ingenuity mission. His interest in coding agents predates the current product: he recalls receiving access to GPT-3 from Greg Brockman in 2020 and proposing a tool that would suggest the next line of code. The ambition has expanded from predicting the next line to learning the programmer’s accumulated judgment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The same date CLI, different defaults
The first demonstration puts Claude Code and Command Code side by side. Command Code shows that taste is enabled, and Awais says it already knows how he built previous CLIs. He gives both agents the same request: make a CLI that tells the date in ISO format. Command begins by picking up a taste file; Awais then enables edit acceptance for both agents. The immediate task is shared, but the available preference context is different.
Command starts assembling a project with TypeScript, tsup, an ASCII-art banner, and npm link. Claude Code produces a quick, minimal result centered on printing the date. That solves the literal request, but it is not the CLI Awais wants to maintain. He starts supplying the missing instructions: use TypeScript, use tsup, and use Commander for command-line control. He also wants lowercase -v for the version option, rather than Commander’s default uppercase -V. This is a convention he prefers, not a defect in Commander. By the time he finishes spelling out those choices, Command has produced the structure he expected. He opens the projects in VS Code to inspect the difference.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Preferences become project structure
The generated project contains another preference Awais forgot to mention to Claude Code: pnpm. It also uses -v, reads the package version rather than hardcoding it in the CLI, and places the date handler in a separate commands directory. That directory matters when the CLI grows: a later human-readable-date command can live beside the ISO-date command, with each handler easier to test independently.
The inspection reveals several small choices that collectively determine whether the project feels familiar:
| Choice | Command output | Claude Code comparison |
|---|---|---|
| Test framework | Vitest | No Vitest |
| Initial package version | 0.0.1 | 1.0.0 |
| Command organization | Separate handlers | Consolidated code |
The difference is preference context, not simply model capability. Awais says Command is also using Claude in this demonstration. The underlying model can produce the desired code; the friction is having to steer it toward the same decisions repeatedly.
The learned preferences are inspectable. Inside the Command Code folder, Awais opens a CLI taste file and says he did not write its contents himself. The displayed taste.md lists preferences with confidence scores, including the tools and conventions reflected in the generated project. He describes the underlying representation as a meta neuro-symbolic model and compares it to a regex of his preferences: a way to recognize patterns in what he wants and apply them more consistently. He then steps back from the demo to explain the architecture, with a paper still promised for the future.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Memory and infrastructure did not capture judgment
The route to Command Code passed through Langbase. Awais reports raising $5 million, with a GitHub founder leading a funding round. The technical problem was memory: he describes a serverless RAG store intended to reason over data, help the user, and keep learning, rather than merely retrieve relevant passages.
But additional infrastructure did not remove the need for corrective prompting. Awais illustrates the problem with a horse on a staircase banister: the initial generated interpretation misses the desired result, and repeated prompting is needed to get there. Langbase supplied primitives such as threads, workflows, and memory to help developers build better agents. Awais reports approximately 700 terabytes and 1.2 billion agent runs per month, without defining the terabyte measure or an agent run in the talk. He points to public research on how people were building agents; Langbase’s State of AI Agents provides a research destination for that broader question.
Writing makes the remaining gap especially visible. Asked for a fun headline for a collaborative developer tool, an agent returns language about the power of synergistic teamwork. A request to fix it makes the result worse. The system can generate plausible marketing text without understanding what this particular writer finds good.
The next attempt was Chai.new, rebranded to Command.new: an agent of agents that accepted a description of the desired agent and provisioned its infrastructure. Awais reports 150,000 agents created with it in five months. Yet generating a functioning agent still did not capture the rules and choices a developer had accumulated over a career. Infrastructure automation addressed how to build and run the system; taste concerned how that system should behave for a particular person.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Learning a rule from a code edit
Awais’s diagnosis is that LLMs pursue quick correctness, while vibe-coding products add context engineering, memory, and prompts that users do not fully control. Developers recover some control by writing CLAUDE.md or AGENTS.md, but enumerating rules creates its own burden. His analogy is the justice system: written rules still need lawyers, judges, and juries to interpret particular situations. For coding agents, he wants the interpretation and acquisition of preferences to happen through ordinary development work.
The smallest example is a JavaScript function signature. Awais prefers an object parameter whenever a function takes more than two parameters. The preference changes the interface, even when the computation stays identical. A three-input sum.js makes the transformation concrete:
javascript
// Before the edit
function sum(a, b, c) {
return a + b + c;
}
sum(1, 2, 3);
javascript
// After the edit
function sum({ a, b, c }) {
return a + b + c;
}
sum({ a: 1, b: 2, c: 3 });
Both calls return the same value. What changes is how callers express the inputs. Awais says Command learns this preference by observing him edit generated code, so a later request can start with the object-parameter form.
The date CLI is the larger version of the same mechanism. Instead of repeatedly requesting pnpm, tsup, TypeScript, and Commander, prior corrections become evidence for future choices. The intended learning signal is the developer’s work itself, not only the instructions they remember to write before generation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Good code depends on where it belongs
For Awais, good code means more than correct output. It reflects choices that make a system readable, maintainable, and humane. If an agent learns those choices, the hoped-for payoff is less review and more work completed. He imagines merging 1,000 pull requests in a day with review time reduced by 90% or 99%; these are aspirations, not measured results. The frustration behind that ambition is receiving familiar, dated patterns—his example is code resembling a 2015 Stack Overflow answer—and having to reshape them on every request.
A useful preference model also needs context. Next.js and Hono both involve API routes, but a choice appropriate in one project may be wrong in the other. Awais wants the agent to recognize the project, resolve conflicts between rules, and associate confidence with the resulting choice. Otherwise, the programmer must continually explain not just a preference, but its scope and exceptions. Time spent teaching the agent competes directly with time spent writing code.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A generative model with an evolving preference layer
Awais describes the architecture as a meta neuro-symbolic reasoning space with reinforcement learning. He positions the symbolic side as more deterministic and explainable than the transformer’s probabilistic generation. The aim is to combine an already capable model—Claude or GPT, or another preferred LLM—with a representation of the programmer’s choices. The regex analogy returns here: the preference layer should recognize relevant patterns and constrain how the generative model responds.
The learning loop is intended to do more than imitate. Awais describes a KL-divergence loop as leaving room for the LLM to correct the programmer when the programmer makes a mistake. Explicit and implicit feedback then update the preference space, which should enforce the otherwise unwritten logic behind choices such as how to organize a TypeScript project. This is an architectural description; the talk does not supply enough detail to derive the objective or implement the correction loop.
He calls the final part reflective context engineering: continuously adapting the context used by the neural, generative component. The architecture slide brings together continuous learning, the meta neuro-symbolic space, and reflective context engineering. These parts are meant to spare the programmer from translating every habitual decision into a rules file.
Preferences must also expire or change. Awais gives a concrete example from his own CLI work: he used to choose Meow, then switched to Commander about two months earlier. An adaptive system should notice that change and update the learned preference without requiring a separate instruction. Remembering an old choice forever would reproduce yesterday’s taste rather than learn today’s.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Packaging taste and evaluating the payoff
At the launch, Awais presents Command Code as a way to pair an LLM’s knowledge of the world’s text with a learned representation of individual intuition and intent. The proposed scope extends beyond one programmer: a team, project, library, or enterprise could have its own taste, shared publicly or kept within a team.
The packaging remains unsettled in the presentation. Awais says the product is new, sharing plans have already changed, and the team is still exploring how to integrate the learned representation into projects. The transparent Markdown file is one way to expose that learning, not necessarily its permanent storage format. He sketches npx taste as a possible way to install his CLI taste and use it with Command Code and a preferred LLM. That is tentative launch-era packaging; the later push/pull interface belongs to the current documentation, not this demonstration.
Awais estimates that Langbase is merging roughly 10× more code into its main repository. He supplies no measurement window, definition of code volume, or evaluation method for that internal result. His joke about disagreeing and committing to main accompanies a more practical observation: he feels more confident reviewing the generated code. Awais also reports significantly lower pull-request review time, without a measured percentage. The closing payoff is therefore about both throughput and the effort of accepting the result: the agent should produce code closer to what the team would have chosen, leaving reviewers less repeated steering to do.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Product overview for the coding agent that learns coding preferences, including the date-CLI example.
JavaScript CLI library with documentation for options, version flags and subcommands.
Langbase’s research on agent builders, model adoption and development practices.
Further reading
A September 2025 account of Langbase’s infrastructure, reported workload scale and Command.new agent generation.
Updates since the talk
Current guidance for using Command Code, selecting models and sharing taste with push/pull commands.
Read the complete timestamped transcript
- 0:00
Well, hello there. Today, I am 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 Command Code: A Coding Agent with Taste.
- 0:11
So who am I? Um, I am Ahmad Awais, creator of Command Code, CEO and founder of Langbase. Um, I've been around this block for, uh, I don't know, like, 20 years, building one thing after another.
- 0:23
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've-- I'm, I'm an engineer.
- 0:33
At the end of the day, I write a lot of code. And I've been building in the LLM space for about five years now. Um, and I think the-- one of the first tools that I actually ended up building was a coding agent.
- 0:44
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.
- 0:58
I want to-- I want it to learn that how I am editing its code. I want it to understand my preferences and continuously adapt to that, uh, you know, preference set and invisible architecture of choices that I have.
- 1:11
And that is what I'm excited to demo today, right? So, uh, the, the story actually [chuckles] begins in 2020, uh, when Greg Brockman gives me access to GPT-3, and I tell him, like, the...
- 1:22
One of the first things, this is like three years before ChatGPT and a year before, uh, you know, GitHub Copilot. I tell him that I want to build something with GPT-3 that suggests, suggests the next line of code, right?
- 1:34
So let's jump into a demo right away, right? Let's, let's look at what this actually looks like, and then I'll, uh, I'll probably explain, you know, how we ended up here.
- 1:44
So on the left here, you see, uh, you know, Claude Code, and this is Command Code, right? This is what we are building. As you can see, it is continuously learning.
- 1:52
Taste is on. This is what we call it. And, uh, I've been building a s- a lot of CLIs. A-as you know, like, you know, if, if you know anything about me, you know that I'm all about automation, and I have been building a lot of, you know, CLIs over the course of my career.
- 2:06
So let's, uh, 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.
- 2:18
So let's give both of them, uh, this thing, right? Uh, make me a CLI that can tell date in ISO format,
- 2:30
right? So look at what is happening here. So one of the first things that happen here is, uh, Command kind of picks up on my taste file. And I'm, I'm gonna share a little bit more about it, but you see what is happening here.
- 2:43
And I'm gonna probably, you know, enable all these settings. So let's give both of these coding agents, uh, you know, a set that it's on. And you can see what Command is doing.
- 2:54
It's, it's using tsup, it's using, uh, TypeScript, and it's, uh, building an, uh, ASCII art [chuckles] you know, banner. It's npm linking. Uh, it's gonna npm link this particular CLI as well.
- 3:07
And the-these are all the things that I kind of care about. And while Claude has done something really good, it, it's very fast, but, eh, I don't know, man.
- 3:15
This is not what I wanted. It's like a console log of, uh, uh, this or that. Like, I, I, I, I, I... When I build a CLI, I don't want to build a CLI, uh, you know, a CLI like this.
- 3:25
I want to build something like, you know, please, uh, use, uh, TypeScript, and I want tsup, right? Um, and what else? I want, uh, Commander because I like to, uh, uh, you know, have, uh, more control over my CLIs.
- 3:42
And what else? I want a lowercased, uh, version number, uh, with hyphen V because I know, you know, Commander does this hyphen capital V thing. Like, I have so many preferences here.
- 3:56
And by this time, uh, Command has already done what I've wanted it to do. How about we actually jump, uh, into code and see, you know, what it has actually done?
- 4:06
Like, let-let's, let's open this up into VS Code.
- 4:12
And this is what Command did for me, right? So it is u-using tsup. It is using TypeScript. It knows pnpm, uh, that I prefer pnpm. Uh, I completely forgot to tell that to, uh, Claude.
- 4:25
And if we go into this particular, uh, CLI here, uh, you can see what it is kind of doing, right? Like, it is using hyphen V, uh, for version.
- 4:35
It is u-- n-not like hard coding 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 directory called commands.
- 4:45
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 gonna put all of these commands here.
- 4:53
It's very, very easy to test that way. I wonder if it is also using Vitest. There you go. Because I prefer Vitest for, uh, you know, writing, uh, uh, a lot of tests.
- 5:02
And one of th-those things, you know, it, it is using zero, zero point zero point one version. I like this dot here instead of one point zero point zero, right?
- 5:10
And that is [chuckles] probably not what, you know, uh, uh, Claude was doing on this side, right? If I were to open the same, uh, CLI that Claude built for me, you will see that, you know, one point zero, and it's like, again, not using Vitest.
- 5:25
Like, every single preference that I have, it is probably not gonna do that. And then again, this thing, everything is here. I don't want it like this. Uh, this is kind of...
- 5:35
Again, it... Claude knows. Claude is a, uh, is an amazing model, but it knows what to do. And with Command right now, we are also using Claude, but it's, it's kind of like I have to steer it so much that I kind of feel like it should be learning from me.
- 5:50
And by the way, it's, it, it, it is quite transparent. If you look at this, we have a Command Code 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.
- 6:02
And these are all my preferences. I can assure you none of this is written by me. So Command Code is continuously learning from me, and it is creating a lot of these taste-like things.
- 6:14
This is not spec, this is not scale. It's like my intuition, uh, built into a meta neuro-symbolic, uh, model or an architecture model that is more deterministic, that kind of figures out.
- 6:25
It's more like a regex of my preferences, and it figures out like this is what I want when I'm using and buil- building, uh, you know, with, uh, writing with AI code or whatnot.
- 6:36
So let's step back in and let's take a step back, uh, why and how we got here, right? And I'm gonna share. We are gonna publish a paper about it as well.
- 6:45
I'm gonna, uh, 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.
- 6:54
So again, I started in 2020. Uh, the first thing I built was a coding agent, and that led to so many things. I ended up building Langbase, and we raised five million dollars from all these amazing people.
- 7:05
In fact, uh, founder of GitHub, uh, led a, uh, round and, you know, founders of all these amazing company- companies kind of supported, uh, you know, our mission here.
- 7:16
And the idea that we, we, 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.
- 7:30
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.
- 7:41
AI is lazy by default. It's really sloppy. If you ask for a, a, you know, horse on a staircase banister, this is kind of what you get. And then you have to, uh, you know, prompt it again and again and again to get to this left side of things.
- 7:53
You know, th- 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.
- 8:04
And our hope was that people will start building amazing agents. And then we saw, uh, you know, like we are doing like I think 700 terabytes and 1.2 billion agent runs a month.
- 8:15
We saw major scale. But we saw another problem. We, we studied that problem and you can go to stateofaiagents.com. You can study all of our, uh, research into how people were building agents.
- 8:26
This is all public, by the way. And we figured out like even agents, uh, were very sloppy. Like, you know, I'm like-- I, I think like I, I use AI for everything except for when I am writing, right? [chuckles]
- 8:40
Because every time I build an agent, uh, to write or, uh, every time I use an LLM to write something, this sort of slop I kind of get back, right?
- 8:50
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, and I actually saw him do this, and he's like:
- 9:00
"Oh God, no, please fix it." And it got even worse, right? Uh, to fix this, we, we tried this Command.new. We launched it as Chai.new and rebranded to Command.new in the last five months.
- 9:11
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.
- 9:19
And I shared a talk about it as well. In five 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?
- 9:38
So we started to fix this problem again, and this is sort of, again, this is-- my five years of learning is around this. I think by default, AI is sloppy.
- 9:47
This is the default setting of almost every LLM. They're trying to be correct, and they're trying to be correct as soon as possible. That I think doesn't really work with code.
- 9:58
And then we get this vibe coding thing where somebody does the context engineering. You know, every- everybody has a different name for it, you know. Uh, behind the scene, it's context engineering, memory and a bunch of prompts.
- 10:09
And you know, you, you-- 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, they start writing these rules files like Claude.md, AGENTS.md, and rules are never enough. [laughs]
- 10:23
I, I often tell, uh, uh, 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?
- 10:42
So I feel like, uh, 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've put this thing taste here.
- 10:52
What, what does that look like? Let me, let me like, uh, like I think this should be something that is acquiring our taste. So, uh, Command Code, a coding agent with taste or, um, uh, if I've, if I'm bold enough to say it's, it's something that is a coding agent with an acquired taste.
- 11:10
It learns what is your taste of writing code and, and this is sort of what it looks like. So I know this might be a very silly and bad example.
- 11:19
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."
- 11:26
I want JavaScript, uh, object parameters. Any time there are more than two parameters, I want that. But AI won't, uh, you know, listen to me. LLMs won't know my preferences of this thing.
- 11:38
So again, when I ask for make me a sum.js function, this is again a very dumbed down version of an example. Um, 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?
- 11:56
And similarly, we, we kind of saw this happen when I asked to build a date CLI. This is, you know, Claude basically started with, "Here is a console log."
- 12:04
And I had to tell it, "No, I, 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?
- 12:21
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,
- 12:44
which is I think what is stopping me to write a lot of code. I wanna generate... My mission is like, what if I could do a lot of things in one day?
- 12:53
What if I can have like 1,000 pull requests merged to main, uh, [chuckles] 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? [chuckles]
- 13:08
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.
- 13:19
I can either write code, or I can teach it to write code. I, I cannot be the one who's, uh, you know, telling it when I'm using Next.js or Hono this, even though those, both of those are, you know, creating API route files.
- 13:32
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, uh, you, you know, that arise from different rules and different projects, right?
- 13:47
So I, I, I do- I don't think I can do that. Again, this is, uh, this excites the hell out of me. I think this is the invisible architecture of choices that every programmer is making, and that is, that is what we are trying to build here.
- 14:00
Uh, you know, a meta neuro-symbolic reasoning space with reinforcement learning. This is, this is a very dumbed-down version, uh, a formula of how we have set this objective. Uh, if, if you don't know, trans-- you know, neuro-symbolic architecture is a more deterministic and explainable architecture than transformers.
- 14:21
Transformers are generative. They, they, 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, right?
- 14:30
They are really good. And you can use whatever LLM with Command Code, but that LLM will be combined with your taste, which is built up, uh, upon this meta neuro-symbolic space.
- 14:40
You can think of it like, uh, you know, a regex of your, uh, 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, [chuckles] you know, correct you as well.
- 14:55
Uh, it's, it's, it's this, 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, uh, around your choices, the architecture that is in your head.
- 15:13
It is in your brain like, "Oh yeah, when I'm building, uh, you know, a TypeScript project, this is the type of thing I do," right? That kind of thing that can never really-- like you, you, your brain can never really translate that into a, you know, rules file.
- 15:27
Otherwise, like you won't be writing code, you'll be writing [chuckles] a lot of rules files, right? And then again, uh, at the end to use the neu- neural part, the LLM part, we have reflective context engineering, which is self-aware, which is continuously learning and adopting.
- 15:42
Like, oh, this guy used to use Meow for writing CLIs, and I don't know what happened, but two months ago, it's-- he switched to Commander. I'm talking about this guy, by the way.
- 15:52
This literally happened, right? And it will automatically update my rules, my, uh, learning from me, my taste that now Ahmad prefers to use Commander over Meow. I don't need to go and teach it.
- 16:06
I should be writing code at, I don't know, Godspeed, [laughs] and it should be learning all of this from me. And over time, we believe that this will turn it, uh, into a skill of intuition that Command Code will have that you can share with your team.
- 16:22
Our mission is to build a huge ecosystem around this. Imagine if you could, if you really like a developer out there, uh, whose React, uh, uh, you know, code is amazing, right?
- 16:33
I, I love what Tanner is doing at Tanner Stack, with Tan Stack, right? So what if I could have Tanner's taste when I'm writing React code? You can do that with Command Code.
- 16:44
What if-- Like one of the things that I have been using it a lot for, like my design engineer has a [chuckles] much better design skill than I do. Uh, whenever I'm writing any kind of front-end code, I actually borrow the design engineer taste I have, which is, which is messy, like all sort, all those margins and paddings
- 17:02
and, uh, amazing tiny little details in his taste that I don't need to now care about. But my LLM in my Command Code, my coding agent kind of puts that LLM in that meta neuro-symbolic design taste alongside my request.
- 17:16
Like, build me a model that does this, but it does it with my design engineer's taste, which is unbelievable, right? So, uh, this is, this is, this is where we are today.
- 17:27
Uh, today we are launching Command Code. You can, you, you can, you know, feel free to go to commandcode.ai, you know, uh, you know, check it out. This is the very beginning of all of it.
- 17:36
Uh, I think large language models have captured the world stacks, 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?
- 17:51
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? [chuckles]
- 18:06
Taste, I totally believe, is going to really, really speed up how we write code. Really, really create that neuro-symbolic, uh, guardrails or, uh, 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
- 18:28
a particular way, right? That is the kind of thing that you would be able to build taste around and share it with, uh, uh, you know, as an open source taste or share it with, uh, just your team.
- 18:39
Like, for example, uh, for example, if you go sign up, uh, again, this is very, very new. Uh, this is potentially it will look like, right? Uh, we've already kind of moved away from, uh, sharing all of this, and we are figuring out, I would love your help to figure out what is the right mix of, uh,
- 18:56
having all of this meta-learning, uh, you know, uh, uh, be part of your projects. Right now, it kind of ends up as more of a, you know, what should I say?
- 19:06
A transparent markdown file, but it could exist in any which way. It's a meta neuro-symbolic space in a model that is continuously learning your preferences, and we can dump that learning in any particular form.
- 19:20
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 Command Code 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.
- 19:37
So yeah, that's pretty much it. Uh, as you can, as you can see, I am pretty excited. Uh, you know, uh, our, our, our, our, our biggest gains that we have seen, uh, in-internally at Langbase are we have probably 10x-ed the amount of code that we are merging, uh, uh, in our main repository, right? [chuckles]
- 19:58
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, um, I, I'm feeling a lot more confident, uh, when I'm reviewing a lot of code, right?
- 20:14
So our review, uh, time for any kind of coding pull requests have gone down significantly, and I can't wait to see, you know, what everybody out there builds with it.
- 20:24
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, uh, you know, what you build with Command Code.
- 20:35
Uh, uh, that's pretty much it. Uh, feel free to reach out and, uh, maybe, you know, uh, send me a tweet or post or whatever you call, uh, we call it these days.
- 20:44
Uh, and I would love to see, you know, what everyone builds. This is me, Ahmad Awais. Uh, thanks for having me. Uh, ciao. Peace.