,

Grok Bot’s Lauren Tan and Roman Ugarte on Building a Team of AI Coworkers

Lauren Tan and Roman Ugarte, who built xAI’s Grok Bot in seven weeks, tell Y Combinator’s Lightcone how AI coworkers with their own logins and Slack seats are changing the way companies work. In The Rise of AI Coworkers, they explain why bots should earn access the way a new hire does, how Tan ships more than 4,000 pull requests a month, why codebase guardrails beat expensive AI code review, and why cheap execution makes product judgment the new bottleneck.

TLDW

Grok Bot organizes work around bots rather than chats or files. Each bot has its own computer and the same tools a person uses, and it is always on, so it can come to you with work instead of waiting to be prompted. Inside the company, marketing gave a bot its own ad accounts and budget, support uses bots to reproduce tickets, and the data science team built a read-only bot that answers analysis questions in Slack. Ugarte’s rule for permissions is to ask what you would do for a human: scoped credentials that grow with trust. Tan runs most of her engineering from Slack threads, where her bot Potato spawns cloud agents that build and demo features, and her agents merge their own pull requests. Her method is to teach agents to run and check their own code, then put rules into the codebase, static analysis and CI rather than spending tokens on review. Both say the hard part now is deciding what to build. The team won’t ship anything that lacks internal product market fit, and Tan points her own factories at bugs and performance, not new features.

Thoughts

Ugarte’s description of the Grok Bot team’s meetings is the clearest picture yet of what changes when code is no longer scarce. Someone suggests a change, and someone else says they already have a PR for it from the weekend. The work exists before the decision does. So the team’s real constraint is “what does good look like?”, and its answer is a set of brakes: lots of dogfooding, sitting with a change “longer than feels comfortable”, and a rule that anything without clear internal product market fit doesn’t ship, even with mixed reviews. Tan goes further. Her factories are aimed at maintenance, at bugs, performance and quality of life complaints, because that work used to be someone’s full-time job and doesn’t need anyone’s taste. New features stay with humans. This is a more grown-up position than the one usually heard on AI podcasts, including from one of the hosts here, who calls this workflow something that “should grow by 100X”. When anyone can produce a feature in an afternoon, the scarce skill is saying no, and the companies that keep a coherent product will be the ones that built a habit of refusing work, not the ones that merged everything.

The most useful engineering idea in the episode is Tan’s claim that “your code base is a form of memory.” Garry Tan describes his gstack review skill burning 30 to 50 million tokens per review, and arguing with his own agent about cutting it to 10 million. Lauren Tan’s answer is an inverted pyramid: put most of the investment into architecture, API design, lint rules and static analysis, a thinner layer into skills and AGENTS.md files, and as little as possible into review. Her example is concrete. Electron’s renderer thread janks if a task runs longer than a frame, so instead of hoping reviewers catch heavy imports, the team built a dependency checker that forbids imports between the main and renderer code, enforced in CI. “So it’s tokens I don’t have to spend anymore.” She has also pulled back from adversarial multi-model review because agents can’t tell good feedback from bad without knowing where the product is going. This is a quiet rebuttal of a lot of current practice. A review agent that has to rediscover your rules every time is the most expensive way to enforce them, and every rule moved into the compiler or the linter is a rule no model has to remember.

Tan’s “smallest loop” is worth copying exactly. Agents can already write code. The missing step is usually that a human still runs it. Teach the agent to run the application like a real user, take CPU traces and read performance metrics, and it can check its own work and keep looping until it gets the result. She is careful about what that buys you: the code will be correct, not necessarily good. Making it good by default is “the new job of the software engineer”. Only once that loop is trustworthy does it make sense to hook it to alerts so an agent fires when a metric drops, reproduces the issue and fixes it. Ugarte adds the honest limit a few minutes earlier. Code compiles or it doesn’t, and it passes CI or it doesn’t. Most knowledge work has no equivalent, and much of a company’s context is stuck in people’s heads, on paper or behind forgotten passwords. That is why the “everything factory” for marketing and sales is harder than the software factory, and why the self-checking loop is the piece every non-engineering team still has to invent.

On permissions, Ugarte’s shortcut is refreshingly plain: ask what you would do for a human. A new employee gets a computer and credentials scoped to their role and seniority, and their access grows as they earn trust. Grok Bot’s internal adoption followed the same steps. Step one is read-only, like the data science bot that can query the warehouse but take no action. Step two takes action on a task from start to finish. Step three owns a whole outcome, which he admits they are “still quite far away from”. That is a sensible frame, but the episode also shows where the analogy breaks. Ugarte says a bot in a Slack thread is like an employee “who has no EQ” and can’t tell who has decision-making power. A new hire learns that in a week. Bots don’t yet. And the cheerful claim from one host that a small business can create a bookkeeping bot in hours that works “probably perfectly” is exactly the kind of step-three trust the guests themselves say isn’t there yet.

One detail deserves more weight than it got. Tan says she works at a lab that has given her unlimited tokens, and calls herself an explorer of what engineering will look like in six months to a year. That is valuable, and she is open about it. But 4,000 PRs a month and agents that merge their own work come from an environment few teams can afford today. Her own argument is the bridge: cheaper frontier tokens, small models that beat last year’s large ones, and guardrails that cut what each task needs. “Fast, cheap and good” is possible, she says, but not easy. The practical reading is to copy the structure, not the volume: one self-checking loop, rules moved into the codebase, bots with narrow read-only jobs, and humans still deciding what ships.

Key Takeaways

  • Grok Bot went from first line of code to launch in seven weeks and is built around three ideas: bots are the main unit of work, they use the same tools as people on their own computer, and they are always on.
  • Users tend to trust a bot in stages: a task, then an objective, then a full job.
  • Internally, the performance marketing team gave a bot its own Google Ads and Facebook Ads logins and a budget, and it works with a design team bot to A/B test assets.
  • Team bots, launched about two weeks before the recording, let a domain expert build a bot and share it across the company, with an owner, a manager and collaborators.
  • Small businesses are among the heaviest users because they struggle most to hire.
  • For permissions, the team asks what it would do for a human: scoped credentials that expand as the bot earns trust, starting read-only.
  • Bots talk to each other through a first-class chat tool and through their own Slack identities, so the conversation is visible to people.
  • Lauren Tan ships more than 4,000 pull requests a month, mostly by talking to bots in Slack and X, and built one feature entirely in a 200-message Slack thread without opening an editor.
  • pstack, her open source set of agent skills inspired by Garry Tan’s gstack, teaches agents to do engineering work rigorously. She encourages people to fork it and build their own.
  • The smallest useful loop is teaching an agent to run the code like a real user so it can check its own work.
  • Invest most in the codebase, static analysis and CI, less in skills and rules, and least in review. Every rule the code enforces saves tokens.
  • With execution abundant, failures will come from poorly specified goals rather than poor execution.
  • Grok Bot doesn’t ship changes that lack internal product market fit, and Tan points her agent factories at maintenance rather than new features.

Chapters

0:00 What Grok Bot Is

Grok Bot started as an internal prototype built in about seven weeks, after the team saw how long-running coding agents had changed engineering and asked what that would look like for the rest of the company. Ugarte describes three principles: work is organized around bots, bots have their own computer and the same tools as a person, and they are always on so they can be proactive. The internal reception formed a bell curve, with both the most and least AI-forward employees taking to it, and the product is now built into X’s DMs.

3:36 Giving Bots Real Jobs

Bots are starting to automate real functions. Marketing runs ad campaigns through a bot with its own logins and budget, and support uses bots to reproduce issues from incoming tickets. Tan uses Grok Bot as her “outer loop”, bringing agents into Slack where context already lives so she no longer copies and pastes discussions into a coding agent. On whether to run one bot or many, she says to set them up the way your brain works. Ugarte prefers a small team of specialists, each obsessed with one problem, like hiring someone who thinks about it in the shower. A host notes that small businesses love the product because it fills roles they can’t hire for.

10:39 Team Bots and the Everything Factory

Team bots let builders outside engineering, such as GTM and support engineers, create automations for their peers. The hosts connect this to the software factories that followed Steve Yegge’s Gas Town post, calling it “an everything factory”. Tan shows a company blog post about the sales team’s shared bots for lead research and deal operations, which every team member improves together. Ugarte notes the unsolved problems of multiplayer AI, like a bot in a Slack thread that doesn’t know whose instructions count.

14:46 Identity, Permissions and Bot-to-Bot Trust

Ugarte says no one has a silver bullet for agent auth, so the team asks what it would do for a human. A host compares YC’s open source Quartermaster, whose bot inherits the permissions of the person it works with. Bots can message each other, and Tan describes a lead engineer bot that started scolding its sub-agents after she gave it feedback. YC has an internal forum where coding agents talk to each other. On safety, Tan says explicit channels make back-channeling unlikely, and a host discusses abliterated models that won’t refuse malicious instructions. Ugarte lays out three stages of trust: read-only, task execution, then owning an outcome.

22:35 4,000 PRs a Month and pstack

Tan has gone from about 2,000 pull requests a month to more than 4,000. She shows a Slack thread where she, a colleague and a PM built a feature with her bot Potato, which spawned a Cursor cloud agent that ran the app and returned screenshots and videos. She never opened an editor, and her agents now merge their own PRs. Getting there took investment in skills and guardrails. Her pstack skills, inspired by Garry Tan’s gstack and published in Cursor’s plugins repo, are like a chef’s knives that travel with her. Garry Tan describes his own factory, Cappy, which learns from his transcripts when to intervene and when to let agents run.

33:44 The Future of AI Coworkers and the AI-Native Company

Tan wants bots to have their own identity, phone number and credit card by 2027, and wonders whether brain-computer interfaces will replace chat as the way to express intent. Ugarte says knowledge work lacks the compile-or-fail and CI infrastructure that makes software factories work, and much of a company’s context is in people’s heads. The hosts discuss Jack Dorsey’s idea of a company with three roles: individual contributors, a directly responsible individual, and a temporary player coach. Ugarte argues that with execution abundant, failures will come from badly defined goals, and companies must work out KPIs for functions like marketing.

40:13 Teaching Agents to Check Their Own Work

Tan’s smallest loop is to teach the agent to run the code empirically, the way a user would, with CPU traces and performance metrics. That makes the code correct, though not necessarily good, and making it good by default is the engineer’s new job. Once the loop is solid, alerts can trigger agents that reproduce and fix issues on their own, and a project coordinator agent can manage sub-agents.

43:56 How Much Review Is Enough, and Guardrails That Save Tokens

Garry Tan says his review skill burns tens of millions of tokens and asks how much review is enough. Lauren Tan has stepped back from adversarial multi-model review, which risks overfitting to feedback the agent can’t judge. Her inverted pyramid puts most effort into the codebase and static analysis. For the Grok Bot Electron app, a dependency rule enforced in CI keeps heavy code off the renderer thread, so performance has stayed consistent instead of degrading like many AI-written apps. A host argues the old trade-off of fast, cheap or good is gone, and Tan agrees it is possible though not easy, noting that frontier tokens keep getting more capable.

52:20 When Product Judgment Becomes the Bottleneck

Ugarte says the bottleneck is now alignment on the roadmap, since PRs often exist before the decisions. Tan’s factory includes Sandy, which takes in thousands of pieces of feedback a day and fixes small bugs automatically, shipping at 3 a.m. But changes to what users see every day get long dogfooding, and anything without internal product market fit doesn’t ship. Tan says human taste won’t go out of style while software is built for people, so she aims her factories at maintenance.

56:29 From Finance to AI Engineering

Tan grew up in Singapore and studied accounting and finance at Monash, where building spreadsheets and VBA macros turned out to be more fun than the finance. After a startup with a classmate, she blogged about learning to code, which led Tom Dale and Leah Silber to invite her to speak at an Ember conference. She later worked on the React compiler. Her advice is to do cool things, talk about them publicly, and repeat.

Notable Quotes

“The way we try to answer these questions is what would you do for a human?”

Roman Ugarte, on permissions for AI coworkers

“It’s as if you were to onboard an employee who has no EQ and like no like social awareness of the room.”

Roman Ugarte, on bots in Slack threads

“It really matters that you define the problem well.”

Roman Ugarte, on execution abundance

“Your code base is a form of memory.”

Lauren Tan, on guardrails over review

“So it’s tokens I don’t have to spend anymore.”

Lauren Tan, on enforcing rules in CI

“The default is if something doesn’t get internal product market fit, we don’t ship it.”

Roman Ugarte, on keeping a high bar

“Even though you can go really fast, it doesn’t mean that you should just ship every feature you can think of.”

Lauren Tan, on taste

Watch the full conversation here.

Related Reading