CommandCode learns a developer's coding preferences from the way they edit generated code.
2
A taste model combines an LLM with a more deterministic, explainable layer that captures a programmer's recurring choices.
3
The system is intended to reduce review work by making generated code fit a person's or team's established practices.
Summary
Ahmad Awais introduces CommandCode, a coding agent that learns how a developer prefers to write software. He demonstrates it building a CLI and choosing TypeScript, tsup, Commander, pnpm, Vitest, separate command files, and a 0.0.1 starting version because those match his habits. Awais argues that ordinary prompting and rules files cannot fully express the choices experienced programmers make across projects. CommandCode records explicit and implicit feedback from code edits, builds a meta neuro-symbolic representation of those preferences, and uses reflective context engineering to apply them later. The proposed system combines an existing LLM with a more deterministic layer, plus a feedback loop that can update preferences when a developer changes tools or practices. Awais also describes sharing taste models with teams or borrowing another developer's style. He reports that Langbase has seen a tenfold increase in merged code and substantially shorter review times internally, though the talk does not provide a controlled comparison.
Awais wants a coding agent to observe how he edits generated code, understand his preferences, and adopt them over time. In the opening demo, CommandCode builds a CLI in the style he normally uses. It selects TypeScript, tsup, Commander, pnpm, a hyphenated lowercase version flag, separate command files, Vitest, and version 0.0.1. These choices are presented as habits the agent inferred rather than instructions he entered for that task. The result is code that matches his working style more closely than a default Claude-generated CLI.
The agent stores taste in a transparent preference file
CommandCode exposes a taste file inside the project. Awais shows a CLI taste section containing preferences that he says he did not write manually. He describes the file as an expression of his intuition rather than a conventional specification or a static scale of rules. The system can therefore make preferences visible while still learning them from behavior. The file is one current representation of the learned state, and Awais says the underlying learning could later be stored or presented in another form.
Rules files cannot cover the situations programmers handle
Awais places CommandCode in a progression from prompting to context engineering, memory, and rules files such as CLAUDE.md and agents.md. He argues that rules are insufficient because software decisions depend on the particular project and situation. The same developer may handle an API route differently in two projects, and the agent needs to recognize that context. His comparison with courts makes the point: written rules still require people to interpret what applies in a specific case. He wants the system to learn the choices behind the rules instead of making the developer document every exception.
Good code includes an invisible architecture of choices
For Awais, programmers do not define good code only by whether it is correct. They also care about whether it is readable, maintainable, humane, and similar to the code they would write. He gives small examples, such as preferring JavaScript object parameters when a function has more than two parameters, or choosing Commander over meow for a CLI. These decisions are often automatic for the programmer and hard to turn into a complete rules file. A coding agent that learns them could let developers spend more time writing and less time correcting basic stylistic and structural choices.
The proposed architecture combines an LLM with learned constraints
Awais calls the system a meta neuro-symbolic reasoning space with reinforcement learning. He contrasts transformers, which are generative and probabilistic, with a more deterministic and explainable neuro-symbolic layer. CommandCode can use an existing LLM, including Claude or GPT, while adding a learned representation of the developer's choices. A Kullback-Leibler divergence loop is part of the design, and the system is intended to correct itself when its output diverges from the user's preferences. The model learns from both explicit feedback and the edits a developer makes implicitly.
The reflective context engineering layer is meant to notice changes in a developer's habits. Awais gives the example of someone who used meow for CLI work and later switched to Commander. The system should update its understanding without requiring the developer to edit a rules document. This makes taste a changing model rather than a one-time configuration. Awais describes the intended result as a form of engineering intuition that can guide future requests while the developer continues writing code.
Taste models could be shared across people and teams
Awais proposes treating learned taste as something that can be shared. A developer could borrow Tanner Linsley's React preferences, or apply a design engineer's frontend preferences when generating interfaces. The borrowed taste would influence the output alongside the user's request and chosen LLM. He also describes possible team, project, enterprise, and open-source taste models. At launch, the representation may look like a transparent Markdown file, with a possible npx taste command for installing someone else's CLI taste.
Internal use reportedly increased merged code and reduced review time
Near the end, Awais reports that Langbase has increased the amount of code merged into its main repository by roughly ten times. He also says the team feels more confident reviewing generated code and that pull request review time has gone down significantly. These are internal observations rather than a detailed evaluation. The talk presents them as the practical reason for teaching agents a developer's preferences: generated code needs less correction before it can enter the team's normal workflow.
"I want it to learn from me. I want it to understand my preferences and continuously adopt to that preference set in invisible architecture of choices that I have."00:56
Who should watch
You are building coding agents and need them to learn developer behavior beyond a static instructions file.
Your team spends time correcting generated code so that it matches project conventions and individual engineering preferences.
You are interested in combining LLM generation with learned, more deterministic representations of coding choices.
