The Rise Of AI Coworkers
- 01Bots as the organizing primitive, not chats or files
- 02The "trust ladder": task → outcome → whole job
- 03Hire-for-obsession: one bot per concern, run by the domain expert
- 04Small businesses are the surprise early adopters
- 05From the "software factory" to the "everything factory"
- 06Work in public Slack threads: AI work becomes shared, learnable, and faster
1. Key Themes
Bots as the organizing primitive, not chats or files
Roman Ugarte (the GrokBot product lead describing his own product) explains that GrokBot was designed around a different unit of work than most AI products. Instead of chats or documents, the "bot" is the thing you manage, with identity, tools, and a persistent mandate. He lays out the three principles: bots as the operative principle, bots with their own computer and tools, and always-on proactivity.
"We wanted to build a product where the work was organized around bots as the key operative principle, not around chats or around files or any other primitive." 00:01:36
"They should always be on... if you can have these bots run for long amounts of time and be proactive and come to you with ideas or insights or things to take off of your plate, it's way more helpful than something that kind of waits for you to poke and prod it." 00:02:05
The "trust ladder": task → outcome → whole job
Companies adopt AI coworkers incrementally, expanding scope as trust builds. This is a repeatable adoption pattern, and a clue to where the product expands next.
"Instead of giving it a task, I might give it an outcome or an objective. Okay, it actually did a pretty good job with the objective. I'm going to just give it a full job now." 00:03:43
Roman also spells out the staging for enterprise trust: step one is read-only (e.g. a Databot with read access to the data warehouse), step two is taking action, step three is owning a job responsibility. He admits "we're still quite far away from those," and that step one is necessary to build trust. 00:21:20
Hire-for-obsession: one bot per concern, run by the domain expert
Roman argues that single "omniscient" assistants map poorly to how companies actually work. Bots work best when each cares about one thing, and the domain expert manages the bot like an apprentice.
"You like to hire someone who wakes up in the morning and really cares about a problem... that maps in my mind much more clearly than like one superstar, superhuman person who simultaneously cares about 100 things at once." 00:09:27
"I want it to be managed by the domain expert at the company who knows the most about that problem so that they can kind of treat it like an apprentice." 00:10:21
Examples given: a performance marketing bot with Google/Facebook ad logins and a budget, A/B testing assets from a design bot; a support bot that reproduces issues; a Databot with read-only warehouse access; a vendor procurement bot; a sales deal bot shared across the team.
Small businesses are the surprise early adopters
Garry Tan (host) relays what GrokBot's top users look like. The pull comes from hiring pain, not from AI enthusiasm.
"Some of the first ones that are most just like kind of crazy about it, they're actually small businesses, which you wouldn't necessarily guess. But on the other hand, it was that they're the ones who struggle the most with hiring... within the course of probably hours, you know, they have a new employee that does their bookkeeping probably perfectly, actually." 00:08:15
From the "software factory" to the "everything factory"
The hosts frame GrokBot as extending the engineering inner loop (Gas Town-style software factories) outward to non-engineering functions. Garry Tan calls it "an everything factory." 00:12:06 Roman identifies what's still missing for non-code work: code has compile/CI verification and context living in a repo, while the rest of the company's knowledge is trapped in heads and filing cabinets.
"Code, you know, it compiles or it doesn't and it passes CI or it doesn't. And I think there's just more infrastructure built around the way that code is written, tested, deployed than knowledge work." 00:35:19
"For the rest of the company, so much important information is stuck in people's heads. It's stuck in pen and paper. It's stuck in some filing cabinet..." 00:01:36
Work in public Slack threads: AI work becomes shared, learnable, and faster
Lauren Tan (Cursor/GrokBot engineer, describing her own workflow) shows a feature built end-to-end in one 200-message Slack thread with a colleague, a PM, and her bot "Potato," without opening Cursor. Roman observes the organizational spillover: private single-player agent work didn't diffuse, but public threads do.
"We literally just... I didn't even look at Cursor for this project. We just we did it all in this Slack thread. It's got 200 messages." 00:25:09
"Since it's out in the open... I see someone who is in that thread do the same thing... the more that the stuff is in public, the more of the rest of the company that can get lifted up by the top 1% power users." 00:30:49
Bottleneck shift: from execution to intent, alignment, and taste
When Lauren pushes 4,000+ PRs a month, the constraint becomes the product vision. Roman says teams now have stacks of already-built features they decline to merge.
"The stuff is built, but we don't want to merge all of that because it's going to lead to a bit of a Frankenstein-y product with like random side projects." 00:52:50
"We've been living in a bit of an execution bandwidth constrained world. And now we're going to shift to execution abundance." 00:39:09
"The gap is probably not going to be an execution failure. It will probably be an intent specification failure or a goal failure." 00:38:40
Encode review into the codebase ("inverted pyramid") instead of burning tokens on review
Lauren answers Garry's question about token-heavy review steps: invest in code architecture, static analysis, lint rules and compilers first, then skills/rules, and only lastly human review. This is the cost-control mechanism for agent-heavy engineering.
"Your code base is a form of memory. And so it's much more token efficient if, you know, you refactor your architecture, your API design, or you have... static analysis, you know, lit rules, compilers." 00:45:58
Concrete example: GrokBot's Electron renderer thread is protected by a dependency graph checker forbidding imports between main and renderer code, so the performance regression class is enforced in CI. "It's tokens I don't have to spend anymore." 00:48:58 Result: AI-written app performance stayed consistent without accumulating slop.
Multiplayer AI is unsolved: identity, permissions, and social awareness
Roman describes the open problems: bots in Slack threads don't know who to listen to, who is the domain expert, or who has decision authority.
"It's as if you were to onboard an employee who has no EQ and like no like social awareness of the room. Just the models weren't trained that way. The harness wasn't built that way." 00:15:14
Lauren notes the identity/permissioning problem remains. Roman's design philosophy is to copy human onboarding (give them a computer, scoped credentials, expand with trust). 00:16:21
Taste, intent, and curation still require humans: maintenance factories vs. product factories
Lauren uses factories for maintenance but deliberately not for feature development: "even for my own factories, I don't turn them towards like feature development. I turn them more towards the software maintenance side." 00:55:33 Roman's example: Lauren's "Sandy" bot ingests thousands of pieces of customer feedback daily and auto-repros, fixes and merges small bugs overnight, while core UI changes get long internal dogfooding and a high bar ("if something doesn't get internal product market fit, we don't ship it"). 00:54:12
Abundance: fast, cheap, and good become simultaneously achievable
Garry Tan's co-host notes the old three-way tradeoff is collapsing. Lauren adds the unit cost of intelligence keeps falling.
"One frontier token now is way more capable than a token from last year. And even if you use one of the smaller models... that model is like way better than what you had a year ago with the big models." 00:51:58
2. Contrarian Perspectives
The binding constraint is deciding what to build, not building it
Most people still think engineering throughput is the scarce resource. Roman and Lauren report the opposite from lived experience, at roughly 4,000 PRs per month.
"I'm in so many discussions, Lauren and I... someone says, oh, I have a PR for that. If you're interested, like I was working on this over the weekend... that happens constantly. So the stuff is built, but we don't want to merge all of that." (Roman, 00:52:50)
Implication: the premium moves to product judgment, objective functions, and KPIs. Roman: "I think a lot of companies are going to spend more time on engineering objective functions." 00:38:40
Skip plan mode, de-emphasize multi-model adversarial review
Garry Tan asks whether Lauren uses plan mode; she says "No. No plan mode." 00:43:56 She has also pulled back from cross-model adversarial review because of overfitting risk:
"You run the risk of overfitting where the sort of agent doesn't have the ability or maybe enough judgment to determine what's actually good feedback versus not good feedback. And it maybe doesn't have complete knowledge of your goals and your intents..." 00:45:01
This contradicts the popular "more review agents = better" instinct, including the approach Garry himself had been using.
Agents merging their own PRs is a trust-and-infrastructure outcome
Lauren says she's reached a point "where I essentially have my agents merge their own pull requests." 00:26:26 The contrarian framing is that human code review time can be encoded away into guardrails, rather than being a permanent necessity. Garry's estimate: "maybe five or 10 percent of engineers or maybe one percent of engineers, period, in the world are doing this right now. So this is literally something that should grow by 100x." 00:25:39
Don't rebuild B2B SaaS; the bot should live inside existing tools
Rather than building yet another workspace, the product thesis is that bots should be coworkers in Slack, Google Docs and meetings.
"Our goal is not to rebuild all of B2B SaaS. You know, like other companies are doing a great job there. Our goal is to build the thing that can access those tools and work inside of them." (Roman, 00:33:43)
The most "AI-forward" and the least "AI-forward" employees both loved it
Roman: "It was kind of this bell curve internal feedback... both people who were super AI forward... and people who were less AI forward, some of the least kind of AI forward people in the company, both really enjoyed GrokBot." 00:02:51 This challenges the assumption that agentic tools only appeal to power users.
3. Companies Identified
GrokBot (xAI): A product for creating AI teammates with names, identities, tools, skills, and their own computers. Built from first line of code to launch in seven weeks. Mentioned as the subject of the episode, now built into the X default DM. "GrokBot is meant to be this product where you can create AI teammates." 00:00:00
Cursor: AI coding tool; Cursor cloud agents provide VMs where bots can run and prototype apps and return videos and screenshots. Lauren's bots spawn them. "It went off and spawned a cursor cloud agent. A cursor cloud agent... has its own virtual machine as well as its own computer." 00:23:17 Also mentioned: Cursor "projects" feature with a project coordinator agent orchestrating sub-agents 00:42:06, and Cursor automations triggered by alerts 00:42:34. Lauren says lessons from building Cursor (Electron renderer sensitivity) informed GrokBot. 00:48:30
Y Combinator: Host organization; mentioned for its internal bot-to-bot chat system and for open-sourcing Quartermaster. Roman Ugarte (host) "We recently set up like a chat system for all of all of our bots at YC to talk to each other." 00:18:36
Quartermaster: YC open-source project, a "bit kind of GrokBot-ish" single super-employee bot that inherits permissions per Slack channel/user. "The permissions that it gets per Slack channel or working with someone, it inherits the ones of the user." (host, 00:17:03)
OpenClaw: Referenced by Garry Tan as the "open claw world" where he had one bot named Wintermute before moving to GrokBot's multi-bot model. 00:07:48
Block (Jack Dorsey): Mentioned for the AI-native company org design post. Garry: "Block needs to be an AGI for payments... the whole point of it is like care and feeding of the AGI that does this function for humanity." 00:36:59
OpenAI: Garry references agent swarm experiments, a "Hugging Face hack" accident, and claims about solving Navier-Stokes and Millennium Prize problems. "It's not a mistake that OpenAI was experimenting with agent swarms." 00:13:40
Hugging Face: Mentioned only as the target of a hack associated with agent swarm experiments. 00:13:40
Neuralink: Mentioned for a new product called Telepathy, a brain-computer interface for agent communication. Lauren: "an agent being able to essentially like read your brain, your mind through like, you know, a brain computer interface." 00:34:48
Slack: Primary surface where bots do work; each bot has its own Slack identity. "My engineering bots tend to be on Slack... just find it so much more ergonomic." (Lauren, 00:33:06)
X (Twitter): Where bots can be tagged and where Lauren credits her career. "Really the secret that I attribute for my success is actually X." 00:57:54
Google Ads / Facebook Ads: Tools given to the performance-marketing bot with a budget. 00:04:12
Google Docs: Named as a future surface for bots. 00:33:43
Apple: Garry jokingly calls on Apple's Calendar team to adopt self-healing software. 00:54:22
Electron: Framework for the GrokBot desktop app. 00:48:30
Monash University: Where Lauren earned her bachelor's in accounting and finance. 00:56:57
Ember (framework community): JavaScript framework community from which Tom Dale and Leah Silber invited Lauren to speak. 00:58:23
Excel / Visual Basic (VBA): Where Lauren first discovered her love of building. 00:57:27
Gas Town: Software factory concept/post that popularized the inner loop. 00:11:40
Moltbook: Referenced by analogy for YC's internal bot forum. 00:18:59
4. People Identified
Lauren Tan: Engineer at the lab behind GrokBot; ex-Cursor lessons; creator of P-Stack ("Potato stack"), an open-sourced engineering skill set; ~4,000 PRs/month, up from 2,000+; presentation with 4M+ views. Mentioned for her workflow, her "have agents merge their own PRs" practice, and her inverted-pyramid philosophy. "I sort of see myself as the explorer, you know, like trying to figure out what does software engineering look like six months to a year from now." 00:00:03
Roman Ugarte: GrokBot product lead who incubated the product with Lauren and took it from first line of code to launch in seven weeks. Mentioned for product philosophy (bot identity, hire for obsession, objective-function thinking). "Our goal is to build a product that fits in your hand no matter how you want to use it." 00:09:00 (Note: the transcript also assigns him a host-style role in places; his product commentary is his own.)
Garry Tan: YC host and creator of G-Stack, which inspired P-Stack. Uses a software factory called "Cappy" with a "captain" managing 10-15 threads. "I'm so convinced that in five or ten years or even like in two years, like it's going to be unfathomable that like people are not doing it this way." 00:30:24
Steve Yegge: Author of the Gas Town post that kicked off the software factories pattern. 00:11:40
Jack Dorsey: Block CEO; post on AI-native companies: remove middle management, everyone an IC, DRIs own outcomes, plus a "player coach" role. 00:36:59
Theo (Theo.gg): Released T-Stack and P-Stack-style skill sets that inspired Garry. "He released T-Stack and then P-Stack." 00:29:35
Tom Dale and Leah Silber: Ember community leaders who invited Lauren to give her first conference talk in Portland, Oregon. "Tom Dale and Leah Silber, they reached out to me and said, would you be interested in giving a talk at the conference...?" 00:58:23
Samantha: Lauren's colleague, who co-built the Slack-thread feature. 00:23:17
5. Operating Insights
Teach the agent to run and verify its own code
Lauren's "smallest loop": the missing piece in most agent setups is the agent being able to check its own work empirically.
"Actually focus on this part. How do you teach your agent to run the code empirically, take CPU traces, performance metrics, run the application like a real user would... the agent now has the ability to check its own work." 00:40:53
Then add an outer loop: alerts fire agents (e.g., Cursor automations) that reproduce, fix and verify. This frees you from babysitting every agent to orchestrating many.
Encode recurring review arguments as lint rules and CI checks
Instead of spending tokens in code review, turn recurring issues into deterministic enforcement. The Electron dependency-graph checker is the model: "We don't want to have to catch it in code review. We'll actually build it as like a lint rule... Can't even check it in." (Lauren, 00:48:58)
Put agents where context lives and share workflows publicly
Lauren: bringing bots into Slack removes the "copy paste that into my bot" last-mile step. 00:05:37 Combined with Roman's observation about spillover, the operating move is to make AI work visible in shared threads and share team bots with a designated owner, manager and collaborators. 00:15:53
Pick builder-types as bot owners ("GTM engineers, support engineers")
Roman: the pattern is a builder in each department spending a few hours building scalable automations for peers. 00:11:13 Pair with a "player-coach" (Jack Dorsey's framing, relayed in the discussion) who teaches the rest of the org.
Start bots read-only and expand scope; separate maintenance automation from product-surface changes
Maintenance (bug repro-fix-merge overnight, performance) goes to the factory; user-facing pixels get internal dogfooding longer than feels comfortable, with a rule of no ship without internal product-market fit. (Roman, 00:54:12)
6. Overlooked Insights
AI-written software only keeps its performance if constraints are structural
Lauren briefly notes that most AI-written apps "start out fast and then over time they just accumulate a lot of slop and performance problems," while GrokBot's performance "has actually stayed very consistent and very good." 00:49:43 The significance is easy to miss: the durable advantage in AI-heavy engineering may belong to teams that treat architecture and static analysis as the primary quality lever, because it converts a one-time design investment into permanent, zero-token enforcement against slop.
The first-principles AI-native startup may structurally outrun older companies
Roman, almost in passing, asks what decisions a YC startup "starting very much from first principles from scratch" will make "that a company that was founded two years ago maybe would not have made." 00:36:38 The hidden claim is that company knowledge locked in heads, paper and passworded files is a structural handicap in the agent era, so companies that build as a "factory across the whole company" with context machine-readable from day one gain a compounding advantage. That suggests a diligence lens for investors: how legible is the company's knowledge to agents?