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

Talk transcript

1. 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.

2. 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.

3. 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.

4. 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.

5. 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.

6. 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.

7. 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...

8. 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?

9. 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.

10. 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.

11. 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.

12. 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.

13. 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,

14. 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.

15. 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.

16. 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.

17. 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.

18. 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.

19. 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.

20. 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.

21. 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?

22. 4:06

    Like, let-let's, let's open this up into VS Code.

23. 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.

24. 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.

25. 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.

26. 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.

27. 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.

28. 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?

29. 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.

30. 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...

31. 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.

32. 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.

33. 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.

34. 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.

35. 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.

36. 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.

37. 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.

38. 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.

39. 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.

40. 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.

41. 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.

42. 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.

43. 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.

44. 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.

45. 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.

46. 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]

47. 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?

48. 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:

49. 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.

50. 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.

51. 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?

52. 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.

53. 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.

54. 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.

55. 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]

56. 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?

57. 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.

58. 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.

59. 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.

60. 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."

61. 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.

62. 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?

63. 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."

64. 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?

65. 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,

66. 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?

67. 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]

68. 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.

69. 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.

70. 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?

71. 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.

72. 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.

73. 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?

74. 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.

75. 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.

76. 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.

77. 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.

78. 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.

79. 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.

80. 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.

81. 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.

82. 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?

83. 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.

84. 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

85. 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.

86. 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.

87. 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.

88. 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?

89. 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]

90. 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

91. 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.

92. 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,

93. 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?

94. 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.

95. 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.

96. 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]

97. 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?

98. 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.

99. 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.

100. 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.

101. 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.