AI Engineer Code 2025
Developing Taste in Coding Agents: Applied Meta Neuro-Symbolic RL — Ahmad Awais, Command Code
Loading slides…
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.
Full transcript
Loading transcript…