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

Ahmad Awais, Langbase

AI Engineer Code 2025

[Talk page](https://ai.engineer/talks/kWOQS3XPZ10-developing-taste-in-coding-agents-applied-meta) · [Video](https://www.youtube.com/watch?v=kWOQS3XPZ10)

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

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?

[0:00](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=0s)

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](https://commandcode.ai/), 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.

![Slide titled “2020 OpenAI GPT3 Invite” with an invitation email and a Greg Brockman message exchange about suggesting code.](https://ai.engineer/api/talk-essay-media/c0480d09ee8c2ffcb1bb05eed97787cac253d1991fafdd087a5d6a549124e580)

A 2020 GPT-3 invitation and a proposal for code suggestions.

### The same date CLI, different defaults

[1:44](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=104s)

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](https://github.com/tj/commander.js) 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.

### Preferences become project structure

[4:12](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=252s)

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.

![Editor displaying taste.md with CLI preferences for pnpm, TypeScript, tsup, Vitest, Commander, command organization, and version output.](https://ai.engineer/api/talk-essay-media/3a8bee29c6e4bf2952f7687f0704fec6d31740e019bd78c7b7adb817060d3743)

The CLI taste file lists preferences with confidence scores.

### Memory and infrastructure did not capture judgment

[6:54](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=414s)

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](https://langbase.com/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.

### Learning a rule from a code edit

[9:38](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=578s)

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.

### Good code depends on where it belongs

[12:21](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=741s)

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.

### A generative model with an evolving preference layer

[14:00](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=840s)

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.

![Slide showing a meta-neurosymbolic objective equation and bullets on continuous learning, meta neuro-symbolic space, and reflective context engineering.](https://ai.engineer/api/talk-essay-media/89b7e8ba60b14c7de0424f5a8fbe76b92dbec17da399e02d47a113343e9dae73)

CommandCode’s proposed learning architecture and objective.

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.

### Borrowing another developer’s judgment

[16:06](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=966s)

Once preferences can be represented separately from the underlying LLM, they can potentially be shared. Awais envisions a reusable skill of intuition and an ecosystem around it. His hypothetical example is borrowing Tanner’s taste from TanStack when writing React code: applying another developer’s characteristic decisions without requiring that developer to review each request.

He also describes a use within his own team. His design engineer has stronger visual judgment, so Awais says he borrows that engineer’s taste for frontend work. A request to build a modal is combined with preferences about margins, padding, and small visual details. The functional request specifies what the modal should do; the shared taste supplies choices about how it should look.

### Packaging taste and evaluating the payoff

[17:27](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1047s)

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.

## Resources

- [Command Code](https://commandcode.ai/) — Product overview for the coding agent that learns coding preferences, including the date-CLI example.
- [Current Command Code documentation](https://commandcode.ai/docs) — Current guidance for using Command Code, selecting models and sharing taste with push/pull commands.
- [Commander.js](https://github.com/tj/commander.js) — JavaScript CLI library with documentation for options, version flags and subcommands.
- [Langbase State of AI Agents](https://langbase.com/state-of-ai-agents) — Langbase’s research on agent builders, model adoption and development practices.
- [Langbase’s Workers Launchpad account](https://blog.cloudflare.com/workers-launchpad-006/) — A September 2025 account of Langbase’s infrastructure, reported workload scale and Command.new agent generation.

## Slides

### 2020 GPT-3 invite

Awais told Greg Brockman he wanted GPT-3 to suggest the next step in code. Brockman sent an API invite, and Awais began building a CLI-based coding agent.

[1:16](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=76s) [Slide about a 2020 GPT-3 API invite and an early coding-agent idea, with email and message screenshots.](https://assets.ai.engineer/sites/aiecode2025/sha256/895a7fa64d2a7382825147fb61ee5758b7f0440ebecbafb3387b1c3783365b1c.webp)

2020
OpenAI GPT3 Invite
Started building a CLI based Coding agent!

openai api invite
Greg Brockman <[redacted]>
Jul 24, 2020, 6:31PM

Welcome to the private beta for our API!

Here’s what you need to know:

## Development mode

Your account is currently in development mode (see below for switching to production mode). To get started, create an account at https://beta.openai.com with this email address (the easiest way is using Google or Microsoft Auth; you can also create an account with email/password). In this mode, you can develop an application or generate outputs that you curate before displaying them to users.

Greg Brockman
@gdb
President & Co-Founder @OpenAI
Joined July 2010 · 706.6K Followers

would love to hear what use-case you have in mind!
Jul 24, 2020, 6:22 PM

👋
Jul 24, 2020, 6:22 PM

One thing I think GPT3 would be able to do is quickly suggest next step in the code we write — sort of like snippets suggestions for code.

sent you an invite :)!
keep me posted on how it goes!
Jul 24, 2020, 7:00 PM

Interface text:
Inbox
[redacted]
to bcc: me

### Coding agents side by side

Awais opens Claude Code beside Command Code and points out its taste: continuous learning indicator.

[1:45](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=105s) [Claude Code and Command Code appear side by side in a terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/471903eccdf933dc2ef70f06e2f84108e3484ce2750093750f95d56c6a7674d3.webp)

Left pane:
Claude Code v2.0.36
Sonnet 4.5
Claude Max
/…/demo/claude-qql

> Try "refactor "
? for shortcuts

Right pane:
COMMAND
Welcome to Command Code by Langbase. Agentic coding agent.
● taste: continuous learning (ctrl+t to expand)
> Ask your question...
? for shortcuts
internal mode (oauth)

Interface text:
tmux attach-session -t demo-cli-qql
[demo-cli-0:node*
"cd "/Users/ahmadawais" 20:49 07-Nov-25

### Building an ISO-date CLI

Both agents receive the same ISO-date CLI request. Command Code reads a taste file, plans a TypeScript project with an ASCII banner, and begins writing configuration files; the other agent writes a small JavaScript CLI.

[2:35](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=155s) [Command Code responds to a request for an ISO-date CLI and lists implementation tasks.](https://assets.ai.engineer/sites/aiecode2025/sha256/afb5d07eca280dcf68d8b9d5ad966d8d3798afd20ab1489b9c4b3f3b1b48ae84.webp)

Right pane:
COMMAND
Welcome to Command Code by Langbase. Agentic coding agent.

> make me a cli that can tell date in iso format

I'll create a CLI tool that outputs the current date in ISO format.

Read (.commandcode/taste/cli/taste.md)
└ Read 15 lines (ctrl+o to expand)

Read (package.json)
└ ✘ Error: File not found or not readable: package.json

Todos (6 items)
□ Initialize project with pnpm and TypeScript setup
□ Configure tsup for building the CLI
□ Create CLI entry point with commander
□ Add ISO date command functionality
□ Add ASCII art banner
□ Test CLI with npm link

Todos (6 items)
□ Initialize project with pnpm and TypeScript setup
□ Configure tsup for building the CLI
□ Create CLI entry point with commander
□ Add ISO date command functionality
□ Add ASCII art banner
□ Test CLI with npm link

Left pane, cropped:
[illegible] tool that displays the current date in ISO format.
[illegible] *.{js,ts,json,mjs}")
[illegible] ahmadawais staff 96 Nov 7 20:44 .
[illegible] ahmadawais staff 576 Nov 7 20:44 ..
[illegible] ahmadawais staff 96 Nov 7 20:44 .claude
[illegible] to package.json
[illegible]-date-cli",
[illegible]1.0.0",
[illegible]: "A CLI tool to display current date in ISO format",
[illegible]ule",
[illegible]: "./cli.js"
[illegible]node cli.js"
[illegible]rl+o to expand)
[illegible] to cli.js
[illegible] node
[illegible] = new Date().toISOString();
[illegible]oDate);
[illegible].js)

Interface text:
tmux attach-session -t demo-cli-qql
Cooking... (15s · ↓ 561 tokens · esc to interrupt)
taste: no chang[illegible]
> Ask your question...
? for shortcuts
internal mode (oauth)

[2:45](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=165s) [Two terminal panes show coding agents building an ISO date CLI; the right pane reads a taste file and creates configuration files.](https://assets.ai.engineer/sites/aiecode2025/sha256/326d691b6f51e3f271cf2a85d3327e3014eb5c54b5a384f54d24a17ac85f5686.webp)

Left pane, cropped:
[illegible]h(ls -la)
total 0
drwxr-xr-x@ 3 ahmadawais staff 96 Nov 7 20:44 .
drwxr-xr-x@ 18 ahmadawais staff 576 Nov 7 20:44 ..
drwxr-xr-x@ 3 ahmadawais staff 96 Nov 7 20:44 .claude

[illegible]te(package.json)
Wrote 16 lines to package.json
{
  "name": "iso-date-cli",
  "version": "1.0.0",
  "description": "A CLI tool to display current date in ISO format",
  "type": "module",
  "bin": {
    "iso-date": "./cli.js"
  },
  "scripts": {
    "start": "node cli.js"
... +6 lines (ctrl+o to expand)

[illegible]te(cli.js)
Wrote 5 lines to cli.js
#!/usr/bin/env node
const isoDate = new Date().toISOString();
console.log(isoDate);

[illegible]h(chmod +x cli.js)
(No content)

[illegible]h(node cli.js)
Running...

Right pane:
Read (.commandcode/taste/cli/taste.md)
└ Read 15 lines (ctrl+o to expand)

Read (package.json)
└ ✘ Error: File not found or not readable: package.json

Todos (6 items)
□ Initialize project with pnpm and TypeScript setup
□ Configure tsup for building the CLI
□ Create CLI entry point with commander
□ Add ISO date command functionality
□ Add ASCII art banner
□ Test CLI with npm link

Todos (6 items)
□ Initialize project with pnpm and TypeScript setup
□ Configure tsup for building the CLI
□ Create CLI entry point with commander
□ Add ISO date command functionality
□ Add ASCII art banner
□ Test CLI with npm link

Write (package.json)
└ File written: package.json

Write (tsconfig.json)
└ File written: tsconfig.json

Interface text:
[illegible]puting... (esc to interrupt)
Shell command allowed (0s · ↓ 180 tokens · esc to interrupt)
taste: continuous lear[illegible]
> Ask your question...
» accept edits on (shift+tab to toggle)
internal mode (oauth)
[illegible]or shortcuts
[illegible]-cli-0:node*
"cd "/Users/ahma[illegible]

### Side-by-side ISO date CLI comparison

Claude finishes a short JavaScript CLI while Command Code builds a TypeScript CLI with tsup, Commander and an ASCII banner. Awais says the simpler result isn't the CLI he wanted.

[3:12](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=192s) [Side-by-side terminals show a simple CLI and its date output on the left, and project setup and source files on the right.](https://assets.ai.engineer/sites/aiecode2025/sha256/4cd6bc7a690572861bd491f30eb661f4597ffb97e4418a1b2821952215832486.webp)

Left pane:
Search(pattern: "*.{js,ts,json,mjs}")
└ Found 0 files

Bash(ls -la)
└ total 0
  drwxr-xr-x@  3 ahmadawais  staff   96 Nov  7 20:44 .
  drwxr-xr-x@ 18 ahmadawais  staff  576 Nov  7 20:44 ..
  drwxr-xr-x@  3 ahmadawais  staff   96 Nov  7 20:44 .claude

Write(package.json)
└ Wrote 16 lines to package.json
  {
    "name": "iso-date-cli",
    "version": "1.0.0",
    "description": "A CLI tool to display current date in ISO format",
    "type": "module",
    "bin": {
      "iso-date": "./cli.js"
    },
    "scripts": {
      "start": "node cli.js"
  … +6 lines (ctrl+o to expand)

Write(cli.js)
└ Wrote 5 lines to cli.js
  #!/usr/bin/env node
  const isoDate = new Date().toISOString();
  console.log(isoDate);

Bash(chmod +x cli.js)
└ (No content)

Bash(node cli.js)
└ 2025-11-08T04:50:44.870Z

Perfect! I've created a simple CLI tool that displays the current date in ISO format. Here's what I created:

cli.js - The main CLI script that outputs the current date in ISO 8601 format
package.json - Package configuration with a bin entry for easy installation

Usage

You can run it in several ways:

1. Directly with Node:
node cli.js

Right pane:
Write (package.json)
└ File written: package.json

Write (tsconfig.json)
└ File written: tsconfig.json

Shell (pnpm install)
└ WARN  1 deprecated subdependencies found: source-map@0.8.0-beta.0

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☐ Configure tsup for building the CLI
☐ Create CLI entry point with commander
☐ Add ISO date command functionality
☐ Add ASCII art banner
☐ Test CLI with npm link

Write (tsup.config.ts)
└ File written: tsup.config.ts

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☐ Create CLI entry point with commander
☐ Add ISO date command functionality
☐ Add ASCII art banner
☐ Test CLI with npm link

Write (src/banner.ts)
└ File written: src/banner.ts

Write (src/commands/date.ts)
└ File written: src/commands/date.ts

Write (src/index.ts)
└ File written: src/index.ts

Interface text:
tmux attach-session -t demo-cli-qql
20:50:49 [16/26]
Drifting… (27s · ↓ 1.1k tokens · esc to interrupt)
taste: contin[illegible]
Ask your question...
accept edits on (shift+tab to toggle)
internal mode (oauth)
[demo-cli-0:[tmux]*
"* ISO Date CLI" 20:51 07-Nov-25

[3:20](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=200s) [Split terminal showing a completed JavaScript date CLI on the left and a TypeScript CLI build in progress on the right.](https://assets.ai.engineer/sites/aiecode2025/sha256/7312e633f27a6de232457eeef510e79a6d66738ef4f396accce4aac51ff3f1ff.webp)

Left pane:
    "bin": {
      "iso-date": "./cli.js"
    },
    "scripts": {
      "start": "node cli.js"
  … +6 lines (ctrl+o to expand)

Write(cli.js)
└ Wrote 5 lines to cli.js
  #!/usr/bin/env node
  const isoDate = new Date().toISOString();
  console.log(isoDate);

Bash(chmod +x cli.js)
└ (No content)

Bash(node cli.js)
└ 2025-11-08T04:50:44.870Z

Perfect! I've created a simple CLI tool that displays the current date in ISO format. Here's what I created:

cli.js - The main CLI script that outputs the current date in ISO 8601 format
package.json - Package configuration with a bin entry for easy installation

Usage

You can run it in several ways:

1. Directly with Node:
node cli.js
2. Link it globally (optional):
npm link
iso-date
3. Using npm start:
npm start

The CLI outputs the current date and time in ISO 8601 format (e.g., 2025-11-08T04:50:44.870Z), which includes the date, time, and timezone in UTC.

Right pane:
└ WARN  1 deprecated subdependencies found: source-map@0.8.0-beta.0

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☐ Configure tsup for building the CLI
☐ Create CLI entry point with commander
☐ Add ISO date command functionality
☐ Add ASCII art banner
☐ Test CLI with npm link

Write (tsup.config.ts)
└ File written: tsup.config.ts

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☐ Create CLI entry point with commander
☐ Add ISO date command functionality
☐ Add ASCII art banner
☐ Test CLI with npm link

Write (src/banner.ts)
└ File written: src/banner.ts

Write (src/commands/date.ts)
└ File written: src/commands/date.ts

Write (src/index.ts)
└ File written: src/index.ts

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☒ Create CLI entry point with commander
☒ Add ISO date command functionality
☒ Add ASCII art banner
☐ Test CLI with npm link

Interface text:
tmux attach-session -t demo-cli-qql
Twinkling… (35s · ↓ 1.2k tokens · esc to interrupt)
taste: contin[illegible]
Ask your question...
accept edits on (shift+tab to toggle)
internal mode (oauth)
accept edits on (shift+tab to cycle)
[demo-cli-0:2.0.36*
"* ISO Date CLI" 20:51 07-Nov-25

### Adding CLI preferences

Awais asks the left-hand agent for TypeScript, tsup, and Commander. On the right, the other CLI has already been built and linked, and its -v command returns 0.0.1.

[3:33](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=213s) [Split terminal showing requests for TypeScript and tsup on the left and a CLI version check on the right.](https://assets.ai.engineer/sites/aiecode2025/sha256/f0690925728f97c3620e78de211b92827c7191d13711219f1adb75006533e469.webp)

Left pane:
… +6 lines (ctrl+o to expand)

Write(cli.js)
└ Wrote 5 lines to cli.js
  #!/usr/bin/env node
  const isoDate = new Date().toISOString();
  console.log(isoDate);

Bash(chmod +x cli.js)
└ (No content)

Bash(node cli.js)
└ 2025-11-08T04:50:44.870Z

Perfect! I've created a simple CLI tool that displays the current date in ISO format. Here's what I created:

cli.js - The main CLI script that outputs the current date in ISO 8601 format
package.json - Package configuration with a bin entry for easy installation

Usage

You can run it in several ways:

1. Directly with Node:
node cli.js
2. Link it globally (optional):
npm link
iso-date
3. Using npm start:
npm start

The CLI outputs the current date and time in ISO 8601 format (e.g., 2025-11-08T04:50:44.870Z), which includes the date, time, and timezone in UTC.

> please us TypeScript

i want tsup
> i want commnad

Right pane:
Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☐ Create CLI entry point with commander
☐ Add ISO date command functionality
☐ Add ASCII art banner
☐ Test CLI with npm link

Write (src/banner.ts)
└ File written: src/banner.ts
Write (src/commands/date.ts)
└ File written: src/commands/date.ts
Write (src/index.ts)
└ File written: src/index.ts

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☒ Create CLI entry point with commander
☒ Add ISO date command functionality
☒ Add ASCII art banner
☐ Test CLI with npm link

Shell (pnpm build)
└ > cmd-qql@0.0.1 build cmd-qql (ctrl+o to expand)
Shell (npm link)
└ added 1 package, and audited 3 packages in 848ms (ctrl+o to expand)
Shell (cmd-qql)
└ [illegible] (ctrl+o to expand)
Shell (cmd-qql -v)
└ 0.0.1

Interface text:
tmux attach-session -t demo-cli-qql
Wrangling… (esc to interrupt · 6s · ↓ 340 tokens)
Tip: Paste images into Claude Code using control+v (not cmd+v!)
Blazing… (49s · ↓ 1.5k tokens · esc to interrupt)
taste: contin[illegible]
Ask your question…
accept edits on (shift+tab to toggle)
internal mode (oauth)
accept edits on (shift+tab to cycle)
[demo-cli-0:2.0.36*  "* TypeScript Usage" 20:51 07-Nov-25

### CLI build comparison

One CLI is already built and linked with a working -v flag, while the other is still being updated with Commander as Awais adds his preferences.

[3:50](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=230s) [Split terminal showing tsup configuration and a lowercase version-flag request beside a completed TypeScript CLI summary.](https://assets.ai.engineer/sites/aiecode2025/sha256/0b8c877ae43fddbc0d439838be548c3dcf008775a04c65e0c268fbaa6cf11b79.webp)

"scripts": {
-  "build": "tsc",
+  "build": "tsup",
   "start": "npm run build && node dist/cli.js",
   "dev": "tsx src/cli.ts"
},
...
"license": "ISC",
"devDependencies": {
  "@types/node": "^22.0.0",
+ "tsup": "^8.0.0",
  "tsx": "^4.0.0",
  "typescript": "^5.0.0"
}

Write(tsup.config.ts)
Wrote 12 lines to tsup.config.ts
import { defineConfig } from 'tsup';
export default defineConfig({
  entry: ['src/cli.ts'],
  format: ['esm'],
  dts: true,
  clean: true,
  outDir: 'dist',
  target: 'node18',
  shims: true,
... +2 lines (ctrl+o to expand)

> i want commnader

Read(package.json)
Read 24 lines
Read(src/cli.ts)
Read 5 lines

i want a lower case version number with -v

Test CLI with npm link
Shell (pnpm build)
> cmd-qql@0.0.1 build cmd-qql (ctrl+o to expand)
Shell (npm link)
added 1 package, and audited 3 packages in 848ms (ctrl+o to expand)
Shell (cmd-qql)
[illegible] (ctrl+o to expand)
Shell (cmd-qql -v)
0.0.1

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☒ Create CLI entry point with commander
☒ Add ISO date command functionality
☒ Add ASCII art banner
☒ Test CLI with npm link

Done! I've created a TypeScript CLI tool called cmd-qql that displays the current date in ISO format. The CLI is now linked and ready to use.

Features:
• Displays ASCII art banner with the CLI name
• Shows current date in ISO format (e.g., 2025-11-08T04:51:25.116Z)
• Version command with -v or --version flag
• Built with TypeScript, Commander, and tsup
• Uses pnpm for package management

Usage:
cmd-qql      # Shows banner and ISO date
cmd-qql -v   # Shows version only
cmd-qql -h   # Shows help

Interface text:
tmux attach-session -t demo-cli-qql
Wrangling… (esc to interrupt · 23s · ↓ 904 tokens)
Tip: Paste images into Claude Code using control+v (not cmd+v!)
Press up to edit queued messages
accept edits on (shift+tab to cycle)
Ask your question...
accept edits on (shift+tab to toggle)
internal mode (oauth)
[demo-cli-0:2.0.36*] "* TypeScript Usage" 20:51 07-Nov-25

[3:53](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=233s) [Two terminal panes show CLI implementation updates and a completed CLI summary.](https://assets.ai.engineer/sites/aiecode2025/sha256/60c1223ef1eef0d2448a4192e1b4960486c442f0c3482a8898cb7e7bf53d13e5.webp)

Read 5 lines

Update(package.json)
Updated package.json with 3 additions
"keywords": ["cli", "date", "iso"],
"author": "",
"license": "ISC",
+ "dependencies": {
+   "commander": "^12.0.0"
+ },
"devDependencies": {
  "@types/node": "^22.0.0",
  "tsup": "^8.0.0",

Update(src/cli.ts)
Updated src/cli.ts with 14 additions and 2 removals
#!/usr/bin/env node

- const isoDate: string = new Date().toISOString();
- console.log(isoDate);
+ import { Command } from 'commander';
+
+ const program = new Command();
+
+ program
+   .name('iso-date')
+   .description('A CLI tool to display current date in ISO format')
+   .version('1.0.0')
+   .action(() => {
+     const isoDate: string = new Date().toISOString();
+     console.log(isoDate);
+   });
+
+ program.parse();

> i want a lower case version number with -v

Test CLI with npm link
Shell (pnpm build)
> cmd-qql@0.0.1 build cmd-qql (ctrl+o to expand)
Shell (npm link)
added 1 package, and audited 3 packages in 848ms (ctrl+o to expand)
Shell (cmd-qql)
[illegible] (ctrl+o to expand)
Shell (cmd-qql -v)
0.0.1

Todos (6 items)
☒ Initialize project with pnpm and TypeScript setup
☒ Configure tsup for building the CLI
☒ Create CLI entry point with commander
☒ Add ISO date command functionality
☒ Add ASCII art banner
☒ Test CLI with npm link

Done! I've created a TypeScript CLI tool called cmd-qql that displays the current date in ISO format. The CLI is now linked and ready to use.

Features:
• Displays ASCII art banner with the CLI name
• Shows current date in ISO format (e.g., 2025-11-08T04:51:25.116Z)
• Version command with -v or --version flag
• Built with TypeScript, Commander, and tsup
• Uses pnpm for package management

Usage:
cmd-qql      # Shows banner and ISO date
cmd-qql -v   # Shows version only
cmd-qql -h   # Shows help

Interface text:
tmux attach-session -t demo-cli-qql
Wrangling… (esc to interrupt · 26s · ↓ 1.0k tokens)
Tip: Paste images into Claude Code using control+v (not cmd+v!)
accept edits on (shift+tab to cycle)
Ask your question...
accept edits on (shift+tab to toggle)
internal mode (oauth)
[demo-cli-0:2.0.36*] "* TypeScript Usage" 20:51 07-Nov-25

### CLI test dependency

Awais checks the CLI’s package file and finds Vitest in both the test script and development dependencies, matching his preference for writing tests.

[4:54](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=294s) [The package file lists scripts and dependencies, with Vitest highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/9215166e69eab8b02f4623ffdeaa01241da8ec755c5af315260dbaacfe3d9cae.webp)

{
  "name": "cmd-qql",
  "version": "0.0.1",
  "description": "CLI tool to display date in ISO format",
  "type": "module",
  "bin": {
    "cmd-qql": "./dist/index.js"
  },
  "scripts": {
    "build": "tsup",
    "dev": "tsup --watch",
    "test": "vitest"
  },
  "keywords": ["cli", "date", "iso"],
  "author": "",
  "license": "MIT",
  "devDependencies": {
    "@types/node": "^22.10.1",
    "tsup": "^8.3.5",
    "typescript": "^5.7.2",
    "vitest": "^2.1.8"
  },
  "dependencies": {
    "@clack/prompts": "^0.8.2",
    "commander": "^12.1.0"
  }
}

Interface text:
OPEN EDITORS
package.json
CMD-QQL
.commandcode
dist
node_modules
src
  commands
    date.ts
  banner.ts
  index.ts
package.json
pnpm-lock.yaml
tsconfig.json
tsup.config.ts
package.json > devDependencies > vitest

### CLI package version

Awais highlights version 0.0.1, the starting version he prefers over 1.0.0 for a new CLI.

[4:59](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=299s) [The package file is open with its initial version highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/f3295c6ea8e07a482b2f1ce52ce93f6095d39cc4bbbb294d9df0c6a6683bf908.webp)

{
  "name": "cmd-qql",
  "version": "0.0.1",
  "description": "CLI tool to display date in ISO format",
  "type": "module",
  "bin": {
    "cmd-qql": "./dist/index.js"
  },
  "scripts": {
    "build": "tsup",
    "dev": "tsup --watch",
    "test": "vitest"
  },
  "keywords": ["cli", "date", "iso"],
  "author": "",
  "license": "MIT",
  "devDependencies": {
    "@types/node": "^22.10.1",
    "tsup": "^8.3.5",
    "typescript": "^5.7.2",
    "vitest": "^2.1.8"
  },
  "dependencies": {
    "@clack/prompts": "^0.8.2",
    "commander": "^12.1.0"
  }
}

Interface text:
package.json — cmd-qql
EXPLORER
OPEN EDITORS
package.json
CMD-QQL
.commandcode
dist
node_modules
src
  commands
    date.ts
  banner.ts
  index.ts
package.json
pnpm-lock.yaml
tsconfig.json
tsup.config.ts
Tabs: tsup.config.ts, index.ts, date.ts, package.json
OUTLINE
TIMELINE
BARREL GENERATOR: EXPORT VIEW
Socket Security: Login
Connect
Live Share
Spaces: 2
JSON
Go Live
Prettier

### CLI package configuration

Awais points to the .commandcode/taste folder, where he says Command Code records CLI preferences it has picked up. The open package.json shows the project's version, scripts and dependencies.

[5:52](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=352s) [The CLI package configuration shows its version, scripts, and dependencies.](https://assets.ai.engineer/sites/aiecode2025/sha256/778b9e444991de49f3dcf90b88e4458ff838c6a0e3a4fdb662bf223a416f47d1.webp)

{
  "name": "cmd-qql",
  "version": "0.0.1",
  "description": "CLI tool to display date in ISO format",
  "type": "module",
  "bin": {
    "cmd-qql": "./dist/index.js"
  },
  "scripts": {
    "build": "tsup",
    "dev": "tsup --watch",
    "test": "vitest"
  },
  "keywords": ["cli", "date", "iso"],
  "author": "",
  "license": "MIT",
  "devDependencies": {
    "@types/node": "^22.10.1",
    "tsup": "^8.3.5",
    "typescript": "^5.7.2",
    "vitest": "^2.1.8"
  },
  "dependencies": {
    "@clack/prompts": "^0.8.2",
    "commander": "^12.1.0"
  }
}

Interface text:
package.json — cmd-qql
EXPLORER
OPEN EDITORS
package.json
CMD-QQL
.commandcode
  taste
    cli
    taste.md
  settings.local.json
dist
node_modules
src
  commands
    date.ts
  banner.ts
  index.ts
package.json
pnpm-lock.yaml
tsconfig.json
tsup.config.ts
Tabs: tsup.config.ts; index.ts src; date.ts src/commands; package.json

### Learned CLI preferences

Awais shows a CLI taste file that Command Code learned from his preferences, including tool choices and a version-only output rule. Each entry carries a confidence score.

[6:06](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=366s) [An editor displays learned preferences for CLI tools, project structure, and version output.](https://assets.ai.engineer/sites/aiecode2025/sha256/10bb63a7e75b5b7034ccf3f17b3efb3dd4c93f1c7855520f0da023e05a50eacf.webp)

# Cli
- Use pnpm as the package manager for CLI projects. Confidence: 0.95
- Use TypeScript for CLI projects. Confidence: 0.95
- Use tsup as the build tool for CLI projects. Confidence: 0.95
- Use vitest for testing CLI projects. Confidence: 0.95
- Use commander for CLI command handling. Confidence: 0.95
- Use clack for interactive user input in CLI projects. Confidence: 0.95
- Use npm link to test CLI tools locally. Confidence: 0.95
- Check for existing CLI name conflicts before running npm link. Confidence: 0.95
- Organize CLI commands in a dedicated commands folder with each module separated. Confidence: 0.95
- Include a small 150px ASCII art welcome banner displaying the CLI name. Confidence: 0.95
- Use lowercase flags for version and help commands (-v, --version, -h, --help). Confidence: 0.85
- Start projects with version 0.0.1 instead of 1.0.0. Confidence: 0.85
- Version command should output only the version number with no ASCII art, banner, or additional information. Confidence: 0.90

Interface text:
taste.md — cmd-qql
EXPLORER
OPEN EDITORS
CMD-QQL
.commandcode
  taste
    cli
      taste.md
    taste.md
  settings.local.json
dist
node_modules
src
  commands
    date.ts
  banner.ts
  index.ts
package.json
pnpm-lock.yaml
tsconfig.json
tsup.config.ts
OUTLINE
TIMELINE
BARREL GENERATOR: EXPORT VIEW
Socket Security: Login
Connect
Live Share
Spaces: 4
Markdown
Go Live
Prettier

### Langbase

Awais says his first coding agent in 2020 led him to build Langbase, which raised $5 million.

[6:56](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=416s) [The Langbase logo appears on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/25ee0270532a8a4fa062df914ff49cf3acf2032db0b4527b3f3ef9bf5a640614.webp)

Langbase

### Memory: Serverless RAG

Awais describes memory as a serverless RAG store intended to reason over data and continuously learn. The slide presents it as a scalable API for developers.

[7:16](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=436s) [Memory product slide describes a serverless, scalable RAG API, alongside colored bars and customer logos.](https://assets.ai.engineer/sites/aiecode2025/sha256/93545bab3ac6bed079df1a974598175923c3606f7e68451ac6abd9f7fc68cb86.webp)

// memory

RAG as a serverless and infinitely scalable API designed for developers.

Trusted by developers at 5000+ companies.
Cisco
Liquid Web
Resend
Google
PAYCHE[illegible]
Netlify
Amazon
Sourcegraph
OpenAI
Sourcegraph
Redwoo[illegible]

### Langbase Products

Langbase’s agent primitives divide the work: AI Memory provides RAG-based long-term memory, Threads stores conversation history, and Workflow supports multi-step agents with timeouts and retries.

[8:02](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=482s) [A table lists Langbase products and descriptions, including agents, memory, workflows, threads, and developer tools.](https://assets.ai.engineer/sites/aiecode2025/sha256/c536f01cb17c978216ae5cb1788a333e8b5c70bde9c0d0f7848d1ec9ee9a1f2e.webp)

Langbase

Products | Description
Command.new | Vibe code any AI agent. Command turns prompts into prod-ready agents
Pipe Agents | Pipes are a standard way to build serverless AI agents with tools and memory
AI Memory | Auto RAG AI primitive for agents to give them human like long-term memory
Workflow | Build multi-step agents with built-in durable features like timeouts and retries
Threads | Store and manage AI agents context and conversation history without managing DBs
Agent | Agents is an AI primitive to build serverless agents with unified API over 600+ LLMs
Parser | AI primitive to extract text content from various document formats, for RAG
Chunker | AI primitive to split text into smaller, manageable chunks for context, for RAG
Embed | AI primitive to convert text into vector embeddings unified API multiple models, for RAG
Tools | Pre-built and hosted tools for AI agents like web crawler and web search with Exa
Langbase SDK | Easiest wasy to build AI Agents with TypeScript. (recommended)
HTTP API | Build AI agents with any language (Python, Go, PHP, etc.)
AI Studio | Langbase studio is your playground to build, collaborate, and deploy AI agents. A complete AI developers platform.

## Full transcript

[0:00](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=0s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=11s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=23s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=33s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=44s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=58s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=71s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=82s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=94s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=104s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=112s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=126s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=138s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=150s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=163s) And I'm gonna probably, you know, enable all these settings. So let's give both of these coding agents, uh, you know, accept edits on. And you can see what Command is doing.

[2:54](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=174s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=187s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=195s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=205s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=222s) And what else? I want a lowercased, uh, version number, uh, with -v because I know, you know, Commander does this -V thing. Like, I have so many preferences here.

[3:56](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=236s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=246s) Like, let-let's, let's open this up into VS Code.

[4:12](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=252s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=265s) 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 -v, uh, for version.

[4:35](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=275s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=285s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=293s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=302s) And one of th-those things, you know, it, it is using zero, zero point zero point one version. I like to start here instead of one point zero point zero, right?

[5:10](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=310s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=325s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=335s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=350s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=362s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=374s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=385s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=396s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=405s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=414s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=425s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=436s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=450s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=461s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=473s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=484s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=495s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=506s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=520s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=530s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=540s) "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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=551s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=559s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=578s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=587s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=598s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=609s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=623s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=642s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=652s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=670s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=679s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=686s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=698s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=716s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=724s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=741s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=764s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=773s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=788s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=799s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=812s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=827s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=840s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=861s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=870s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=880s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=895s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=913s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=927s) 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 adapting.

[15:42](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=942s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=952s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=966s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=982s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=993s) I, I love what Tanner is doing at Tanner Stack, with TanStack, 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1004s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1022s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1036s) Like, build me a modal 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1047s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1056s) Uh, 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?

[17:51](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1071s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1086s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1108s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1119s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1136s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1146s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1160s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1177s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1198s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1214s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1224s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1235s) 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](https://www.youtube.com/watch?v=kWOQS3XPZ10&t=1244s) 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.
