The Twenty Minute VCInside Legora's Tech Stack: Why Token Maxing is Failing Enterprise Startups | Legora CTO
CHAPTERS
- 0:00 – 1:33
AI tooling ROI: spending on tokens vs. opportunity cost
The conversation opens with a blunt framing: AI tooling spend shouldn’t be evaluated as a line-item cost, but as the opportunity cost of moving slower in a hyper-competitive market. Jacob argues that even meaningful token spend is trivial compared to the downside of missing product velocity.
- •Tooling budget should be tied to opportunity cost, not token price
- •Competitive markets punish slower iteration more than they punish spend
- •Velocity improvements compound across the organization
- •Sets the tone: optimize for output, not optics
- 1:33 – 3:17
Building engineering orgs in 2026: no priors, constant iteration
Jacob explains why being “naive” about traditional engineering-org playbooks can be an advantage right now. With AI rapidly shifting workflows, he treats org design like product design—iterate continuously based on what’s working.
- •Engineering org building is changing faster than old playbooks can keep up
- •Operate with humility: test processes, keep what works, discard what doesn’t
- •Treat org/process iteration like product iteration
- •Team feedback loops are essential to staying adaptive
- 3:17 – 5:38
Code is cheap now: the new bottlenecks are product work and review
AI-assisted development compresses the “write code” phase that used to dominate delivery timelines. Jacob breaks software creation into product definition, implementation, and review/merge—arguing that the bottleneck has shifted to PM/product synthesis and code review.
- •AI tooling (e.g., Claude Code/Cursor) increases individual engineer throughput
- •Implementation used to be the rate limiter; now it’s heavily compressed
- •Primary bottlenecks become product definition and code review
- •Focus should be continuously on identifying and removing the current bottleneck
- 5:38 – 7:09
Why AI code review is still broken (and what review should become)
Legora uses AI review bots today, but Jacob describes the tooling as immature and misaligned with what actually matters. He argues reviews should focus less on line-by-line diffs and more on architecture, stability, and security boundaries—escalating to humans only for strategic trade-offs.
- •AI reviewers can do specialized checks (security, style, etc.) but aren’t “there” yet
- •Current review paradigms over-emphasize reading old lines of code
- •High-value review is about system direction: architecture, stability, boundaries
- •Future model: agents iterate, humans intervene only on meaningful design changes
- 7:09 – 10:19
The future engineer: systems design + ‘meta engineering’ for agents
Jacob predicts engineering shifts one abstraction level up: designing systems and orchestrating agentic work rather than hand-writing most code. He also introduces a growing discipline: building the internal infrastructure, rules, and feedback loops that make agents reliable and effective.
- •Engineer role moves from coding to system design and strategic trade-offs
- •A new core job: making agents effective (agent DX analogous to developer DX)
- •Need data loops and guardrails so agents can run experiments safely
- •Guardrails become a mechanistic enforcement layer for large codebases and many agents
- 10:19 – 12:00
AI-generated code reality: >50% output, but security risk stays human-owned
Jacob shares that AI tools are producing more than half of Legora’s code output—outpacing any single engineer. Despite the productivity gains, he’s explicit that AI-generated code increases the security burden, so human review remains mandatory today.
- •Claude/Cursor are top “contributors,” exceeding 50% of code output
- •AI output increases vulnerability risk and threat-actor efficiency
- •Legora still reviews every PR due to enterprise security requirements
- •Goal: evolve toward risk scoring and smarter review gates without sacrificing safety
- 12:00 – 15:08
AI speeds up postmortems and PM prototyping (and reshapes the SDLC)
Operational processes are being compressed as well: incident response and postmortems become faster with SRE/incident agents synthesizing telemetry and drafting write-ups. On the product side, PMs can prototype and user-test earlier, reducing wasted engineering cycles by front-loading validation.
- •SRE/incident agents can triage logs/metrics quickly and draft postmortems
- •Fewer humans need to context-switch during incidents; responders are better equipped
- •PMs can prototype and iterate with users before involving engineering
- •Shift: prototype-to-value first, then engineers productionize reliably within the system
- 15:08 – 17:28
Taste and design in the AI era: avoiding ‘gray convergence’
Harry challenges whether “taste” is real differentiation or Silicon Valley defensiveness. Jacob argues taste is fundamentally an opinionated stance—clear edges about what you do and don’t do—preventing AI-generated sameness across products, while design shifts toward system-level consistency.
- •Taste = opinionated stance and identity, not superficial aesthetics
- •Without taste, AI output converges into indistinguishable ‘slop’
- •Feature-level design debates may shrink; design language/consistency matters more
- •Figma remains useful as a shared source of truth for UI components and patterns
- 17:28 – 25:30
Shipping faster than customers can adopt: bridging AI speed to human speed
Legora can build far faster than lawyers can absorb change, creating a mismatch between AI/product velocity and user adoption velocity. Jacob frames this as both a challenge and the core mission: translating AI speed into meaningful productivity gains for historically underserved workflows.
- •Three speeds: AI development, product shipping, and human adoption
- •Legal is historically slow-moving, making enablement and change management critical
- •Value comes from removing ‘awful work’ and elevating strategic legal work
- •Vibe coding becomes a constant internal capability, not a novelty
- 25:30 – 31:00
Model strategy: routing across ~10 models, latency vs quality, and open-source stakes
Jacob explains that model choice changes frequently, so Legora optimizes by decomposing tasks and routing to the best model per job. He prioritizes output quality over latency for legal users, and argues open-source models are vital for sovereignty, security, and avoiding monopolistic control.
- •Model leaderboards shift quickly; continuous evaluation is required
- •Use-case decomposition enables routing to different models (not cost-first—yet)
- •For lawyers, higher quality is worth waiting longer
- •Open source is accelerating; sovereignty/security concerns make it strategically important
- 31:00 – 35:31
Learning from Harvey: hiring aggression, scaling teams, and developer experience as leverage
Asked what Harvey did better, Jacob points to hiring aggressiveness and admits he underestimated Legora’s staffing needs. He also calls the developer experience team an underrated force multiplier—building local setups, internal agents, review automation, and onboarding acceleration.
- •Jacob’s earlier ‘cap at 20 engineers’ view proved wrong; Legora is ~80 and still small
- •Constraint isn’t coding speed—it’s feature capacity and breadth
- •Developer experience team builds: fast local dev, background agents, review agents, onboarding tooling
- •Compound gains: when engineers 10x, making them 20% more efficient is enormous
- 35:31 – 43:23
Token maxing is a trap: measure outcomes, not usage (and the IDE will change shape)
Jacob critiques enterprise “token maxing” driven by leaderboards and performance-review incentives. He recommends demos and hack-day style sharing to reward output, and suggests tooling intermediaries can optimize spend—while predicting traditional IDEs will fade in favor of higher-level, system-centric interfaces.
- •Token leaderboards + perf reviews create perverse incentives (burn tokens to look good)
- •Reward impact and output; use demos/hack days to spread best workflows
- •Third-party tooling can help optimize routing/limits across models
- •The IDE’s future likely isn’t reading code lines; it may be architecture/graphical-first with agents executing
- 43:23 – 57:42
Hiring, culture, and scaling in Stockholm: low ego, high velocity, and the ‘level above’ future
Jacob describes how co-location reduces handover cost and speeds execution, while hiring for low-ego, problem-focused engineers makes integration (including acqui-hires) easier. He closes with a broader prediction mirroring software: lawyers will work one level above contract text, focusing on negotiation stance and risk rather than Word-level drafting.
- •Co-location (PM/design/engineering together) minimizes handovers and meetings
- •A-player density matters; B-players erode trust and retention of top talent
- •Low-ego hiring signals show up early (title fixation vs problem excitement)
- •Prediction: law shifts ‘one level above’ contract language to intent, risk, and negotiation posture
