By playing, you agree to uListen's Terms and Privacy Policy and YouTube's Terms of Service.
The Pragmatic EngineerSoftware factories and code reviews with Harjot Gill
Summaries, chapters, transcripts, and FAQs on this page are made by uListen, not YouTube.
Great conversations run long. Their best ideas don't have to.
uListen is free on iPhone, iPad, Android, Chrome, and Claude.
See howCHAPTERS
Jump to publisher timestampsChapter summaries
AI spend, defect rates, and a provocative take on “human slop”
Harjot opens with the scale of his personal AI spend and argues that higher AI-driven velocity has not increased defects at CodeRabbit. He claims teams used to ship low-quality work without sufficient validation, and says stronger validation loops are now reducing outages even as output rises.
- •Harjot cites his personal AI cost as roughly $250K–$275K per month
- •He claims CodeRabbit is seeing fewer defects as velocity increases
- •He argues AI can write “less slop” if it can validate against something
- •The host probes whether past teams shipped low-quality work due to lack of validation
How one person merged 5,000+ PRs in a month using agent workflows
Harjot explains the jump in his pull request volume and what changed when models became capable enough to ship real work. He describes spending much of this output on removing bottlenecks in the SDLC—CI fixes, flaky tests, caching, and other “janitorial” work—while keeping multiple agent sessions busy.
- •Harjot attributes the inflection to agents becoming good enough to ship to production
- •Most PRs are focused on fixing SDLC bottlenecks (CI, flaky tests, caching, infrastructure)
- •He says the current throughput is still far from what agents could achieve
- •He compares his work to keeping a fleet of agents continuously busy
Tooling and lifestyle changes: Codex desktop, multiple sessions, and “AI drives the car, AI drives the company”
Harjot describes shifting away from a traditional editor (after years of Neovim) to a desktop agent workflow. He shares how he runs many concurrent sessions, how this affects sleep, and even how he issues agent instructions during his commute while the car drives itself.
- •Harjot says he no longer codes in a traditional editor after adopting Codex desktop
- •He runs many concurrent sessions and measures progress by how many agents stay active
- •He describes reduced sleep due to the perceived opportunity cost of idle agents
- •He describes sending instructions while commuting with self-driving enabled
Making non-engineering work agentic: code-driven marketing and ads deployments
As engineering output accelerates, Harjot says other parts of the business must move at “agentic speed” too. He describes refactoring marketing into a code-centric workflow, including a “content studio” repo and a process where pull requests can deploy updated ads.
- •Harjot says marketing became a bottleneck as shipping volume rose
- •CodeRabbit built a “content studio” where slide decks and assets are defined in code
- •He describes running ads through code, with agents proposing changes via PRs
- •Merging a PR can deploy changes directly to Google Ads
Harjot’s path into startups: telecom foundations, PhD route, and two prior companies
Harjot recounts starting in a telecom startup later acquired by Alcatel-Lucent and learning distributed systems there. He came to the US for a PhD with the explicit goal of incubating ideas, then founded and sold his first startup, followed by a second startup focused on reliability and load control.
- •Early career in a telecom startup acquired by Alcatel-Lucent, learning distributed systems
- •He pursued a PhD at the University of Pennsylvania with the intent to spin out a startup
- •First startup Netsil focused on observing microservices/network behavior as monoliths split
- •Second startup Flux Ninja focused on load shedding, graceful degradation, and controllability
Early conviction about AI: Copilot as the signal and the code review bottleneck
Harjot explains why GitHub Copilot (pre-ChatGPT) made him confident AI would write most code. He says his experience as a hands-on engineering leader helped him recognize second-order effects, and that code review was already becoming a constraint as output increased.
- •Harjot says seeing Copilot made it “very clear” AI would write most code
- •He frames his leadership focus as removing bottlenecks to reach milestones faster
- •He describes Copilot producing complex code from comments and being “magical”
- •He says code review was already a bottleneck, leading to stacked PR approaches and an internal tool
Founding CodeRabbit and discovering a bigger-than-expected market
Harjot describes how CodeRabbit started from the idea that code review would become a bottleneck, but the opportunity turned out larger than anticipated. He contrasts initial expectations (based on earlier code quality/security tools) with growing demand for AI code review, including many individuals paying.
- •CodeRabbit began with the belief that code review would become a major bottleneck
- •Harjot expected a market size comparable to earlier GitHub ecosystem tools
- •He says demand expanded because many non-traditional buyers want AI code review
- •He notes individuals pay for the product even though the company doesn’t primarily sell to individuals
Switching to AI coding: “code is a means to an end,” long-running goals, and hill climbing loops
Harjot explains he doesn’t miss handwriting code because he prioritizes rapid validation and shipping. He gives examples of agents running for weeks on goals, describes “hill climbing” as verification-driven loops, and outlines layers of validation from local checks to production rollouts.
- •Harjot says coding is a means to reach business value and validation faster
- •He describes agents completing long-running goals (including work he says is in Rust) without him reading the code
- •He defines hill climbing as loops where agents verify work against something and iterate
- •He describes progressive rollout strategies as turns in a strategy game, with learning each release
Software factories: from “potter’s wheel” chats to hands-off agent fleets and cloud constraints
Harjot defines “software factory” as running continuous agent loops across development, CI, and production—not just interactive prompting. He explains operational realities: flaky tests resetting merge queues, agents monitoring key services, limitations of chat as an interface, and local machine constraints pushing work to the cloud.
- •Harjot contrasts interactive crafting (UI via chat) with factory-style hands-off hill climbing
- •He describes continuous agents for tasks like removing flaky tests and monitoring critical components
- •He says chat isn’t the right interface for managing agent fleets at scale
- •He cites local compute limits (RAM, session count) and argues cloud environments are necessary
What replaces human code review: shifting gates to PRs/releases, risk scoring, and “driver’s license” privileges
Harjot argues human line-by-line code review is effectively dead, but human judgment and risk assessment remain essential. He describes a workflow where the pull request becomes the gating point for deciding what should ship, and where CodeRabbit reviews releases using risk indicators; engineers can lose autonomous shipping privileges if regressions persist.
- •Harjot says upstream planning gates have weakened because AI can go from idea to code quickly
- •He says the PR becomes the key gate where humans decide whether to ship or close “slop”
- •CodeRabbit reviews releases (with risk indicators) rather than reviewing every PR in detail
- •He describes a “driver’s license” model: too many regressions remove the right to ship without review
Technical debt, “deslopping tests,” CI cost explosion, and the CPU crunch
The conversation moves to the operational cost of agentic development: CI usage, test strategy, and compute scarcity. Harjot describes agents continuously removing redundant or low-value tests (“deslopping”) while trying to keep CI times low, and he details constraints like limited CPU availability and having to build internal CI to control costs.
- •Harjot says unleashing agents increases entropy, requiring agents to do ongoing cleanup/refactoring
- •He describes “deslopping tests” by removing useless/redundant tests and shifting emphasis toward broader testing
- •He reports CI spending surged and claims a vendor run rate would have been extremely high, prompting an in-house CI build
- •He describes a broader CPU/RAM crunch affecting their ability to scale infrastructure
Evals and model routing: constant benchmarking, ensembles, and why fine-tuning the harness matters more than the model
Harjot explains how CodeRabbit evaluates models amid rapid release cadence and uses multiple models for different sub-tasks. He says the team is constrained by eval capacity, emphasizes model routing for price/performance, and argues the core advantage is in context and harness design rather than custom fine-tunes.
- •Harjot says frequent new model releases force near-continuous evaluation
- •CodeRabbit uses an ensemble and routes workloads to different models rather than exposing model choice to users
- •He says fine-tuning models had short shelf life as frontier models improved quickly
- •He emphasizes “fine-tuning the harness”: context selection, semantic/code graph analysis, and controlling token cost vs quality
Formal methods in practice: TLA+ modeling, simulations, and finding race conditions
Harjot details where formal methods fit into their workflow, particularly for distributed state and message interactions. He describes modeling a Slack bot system in TLA+ and pairing it with simulation/fuzzing harnesses to explore interleavings and identify race conditions before and after deployment.
- •Harjot says they started using formal methods around building the Slack bot product
- •He describes TLA+ as most helpful for actors/messages/interactions rather than pure algorithms
- •He says TLA+ surfaced race conditions they had overlooked
- •They also built a simulation harness to fuzz interleavings and uncover bugs
AI cost at CodeRabbit and why the spending doesn’t scare him
Harjot shares the scale of token spending across the company and ties it to running background agents and maintaining sandboxes and CI. He argues spending is justified when it is auditable and clearly tied to value, and suggests cloud-based collaboration can improve visibility compared to opaque local token usage.
- •Harjot reiterates personal AI spend and says company-wide token spend reaches several million per month
- •He notes background agents also open PRs based on system health signals
- •He frames cost management as routing tasks to cheaper models when possible while still using expensive models for hard work
- •He argues cloud-based workflows improve auditability versus local token spending
Funding and competition: why “software factories” change seed economics and compress the window for mindshare
Harjot defends the idea that VC startups may need more capital because tokens, CI, and compute become major levers for speed. The host pushes back, and they refine the claim: for companies trying to win fast-moving markets, time-to-mindshare is shorter, copying happens faster, and competition includes big tech and labs as well as startups.
- •Harjot says bottlenecks are shifting from talent cost to token/compute-driven execution
- •He argues teams can drive very large spend with fast decision-making, similar to marketing spend dynamics
- •They discuss the risk of being copied quickly and the need to move fast for mindshare
- •The host highlights broader competition: large companies launching dev tools and internal tooling becoming products
Hiring and team structure: field sales growth, strategy-game instincts, and real-time war rooms
Harjot explains where CodeRabbit is hiring rapidly (notably sales) and where they are rethinking roles. He describes looking for agency, range, and adaptability in engineers, and outlines “war rooms” where cross-functional teams craft software in real time as everyone touches the product through PRs.
- •Harjot says field sales is hard to accelerate and remains a hiring focus due to “last mile” onboarding needs
- •He emphasizes hiring for agency and range of experience, not just conventional seniority
- •He reiterates the strategy-game analogy as a proxy for managing parallel agent work
- •He describes war rooms/pods using shared plans and face-to-face collaboration to craft product and UI quickly
Work pace, sleep patterns, and burnout: tending agents, polyphasic sleep, and outcome-driven motivation
Harjot discusses the intensity of keeping agents unblocked, comparing it to Roombas getting stuck and describing a polyphasic sleep schedule. The host challenges the sustainability, and Harjot connects burnout more to lack of outcomes than to hard work, contrasting his second startup experience with CodeRabbit’s traction.
- •Harjot describes waking at night to unblock agents that stall with questions
- •He says local-machine development contributes to the need for constant tending and weak collaboration
- •He claims burnout comes from working hard without results, not from hard work itself
- •He says CodeRabbit’s traction (revenue, customer love, momentum) makes the workload feel sustainable
Skills for the AI era and a closing “Black Swan” framing
Harjot identifies the traits he values most in the current era: agency (including side projects) and breadth of systems experience, with AI providing depth on demand. He closes by recommending a book he associates with “black swan” moments and frames the current AI shift as hard to predict and still far from peak.
- •Harjot says agency is the top signal, and lack of side projects is a red flag
- •He values range of experience (systems thinking across domains) to direct agents effectively
- •He reiterates that value creation and frontier work motivate him more than manual coding
- •He frames the moment as a “black swan” and says the industry hasn’t hit peak capability yet
Publisher timestamps
- 0:00Intro
- 3:17How Harjot shipped over 5,000 pull requests in a monthRead this chapter
- 8:46Harjot’s path into tech and his first startupsRead this chapter
- 12:25Early conviction around AI and founding CodeRabbitRead this chapter
- 14:40Switching to AI codingRead this chapter
- 20:35Software factories explainedRead this chapter
- 25:37What’s replacing human code reviewRead this chapter
- 38:44Technical debt and deslopping testsRead this chapter
- 46:05Evals
- 50:25Formal methodsRead this chapter
- 52:05AI cost at CodeRabbitRead this chapter
- 54:57Startup funding in 2026 and the value of AI spend
- 1:08:20Hiring
- 1:13:03Work pace, sleep, and burnoutRead this chapter
- 1:21:55Skills for the AI eraRead this chapter
- 1:24:30Book recommendationRead this chapter