Jonathon's AI Wiki

Running an AI-native engineering org (Fiona Fung, Code with Claude London 2026)

10 min read

Source: Running an AI-native engineering org (YouTube igO8iyca2_g), Fiona Fung (Engineering + Product Lead, Claude Code + Cowork at Anthropic), Code with Claude London 2026 (May 21 2026). Prior tenure: Meta (Facebook Marketplace, AR/VR), Microsoft (Visual Studio 2005).

How Anthropic itself runs the Claude Code + Cowork team. Fiona’s frame: the bottleneck has shifted — coding throughput went from expensive to cheap; review, verification, cross-functional coordination, security, and product judgment became the new constraints. The talk walks through the team-norm rewrites that flowed from that shift: just-in-time planning (“don’t we need a six-month roadmap?” → 3-month plans go stale fast), code-wins-the-debate (“instead of a whiteboard, I generated three PRs”), explicit-permission-to-kill-old-processes (Fiona’s favourite team principle), flat org shape (“managers start as ICs”), and roles blurring (PMs ship code, engineers write content-design copy with Claude). Includes the concrete metrics Anthropic watches (onboarding ramp-up time, PR cycle time, % Claude-assisted commits) and a closing audit prompt — “pick your noisiest workflow and ask: is it still serving what’s the purpose of there?”

Key Takeaways

The shift — what served you may no longer serve you

  • Engineering bandwidth used to be the expensive thing. Every process — waterfall, agile, planning rituals, code-review SLAs — was structured around that constraint. Fiona’s career started shipping Visual Studio 2005 on CD-ROMs; deadlines were hard because boxes had to ship physically. Online distribution changed how software shipped. AI-assisted code is changing it again.
  • Coding is rarely the slow part anymore. Not just faster — throughput went way up too. The amount of code being generated has changed dramatically, not just the speed per unit.
  • The new bottlenecks. Verification, review, cross-functional partners, security. “Is this code correct? Who reviews this code?” is the most common question Fiona gets from other engineering leaders. Code maintenance cost is also up because there’s more of it.
  • Processes rarely kill themselves — they layer. Fiona’s recurring observation across Meta + Microsoft + Anthropic: SLAs stack on top of SLAs until teams have to stack-rank SLAs. Defragmentation is the managerial skill that’s now load-bearing.

Team norms the Claude Code team rewrote

Planning — less of it, just-in-time.

  • Initial instinct on joining: “Don’t we need a six-month roadmap?” Tried it. Stale in 3 months. “Just-in-time planning, almost like JIT compiling.”
  • Fewer design docs before code. Cloud Code: most discussions are in PRs, not docs. “Hey, we found an idea — go prototype.” Code becomes the discussion artifact.
  • Fewer product reviews — prototype, get internal users on it, ship to the public, get external feedback.

Technical debate — code wins.

  • Fiona’s first refactoring debate with Boris: about to go to a whiteboard. Caught herself: “Wait — I can just generate all three options.” Generated three PRs.
  • The win wasn’t just on implementation. Each PR showed impact on callers — so the debate covered both the API and the integration cost.
  • Cultural caveat: cheap code does not mean “the last-PR-checked-in wins.” That makes alignment culture more important, not less.

Code ownership — “who made this change?” needs double-clicking.

  • Most PRs are Claude-assisted. The literal answer to “who made this change?” is awkward.
  • Reframe by what you’re really asking: Who can answer a customer question? Who’s the expert on this subsystem? Who caused this regression? Each lands on a different action — and several can be automated.
  • Fiona’s example: morning customer-feedback summary. Used to be a manual ritual. Then a Claude desktop session. Then a routine (“with my morning coffee…”).

Code review — split between Claude and humans deliberately.

  • Claude handles: styling, lint, PR-feedback responses, sometimes catching/fixing bugs pre-commit, adding tests, babysitting the PR through CI.
  • Humans still required for: expertise + risk tolerance + product taste. Legal review. Trust-boundary + security-sensitive code. Product sense — Fiona’s snowman-vs-Mr.-Peanut ASCII-art anecdote: Claude rendered the holiday-themed snowman ambiguously; her design partner spotted “you turned Claude into Mr. Peanut.” Iteration converged on “ice blue Claude with snowflake.”

Team makeup — two profiles, not “raw throughput.”

  • Creative builders with product sense. Curiosity, “here’s a problem I could maybe solve,” lots of iteration on delightful UX.
  • Deep systems expertise. When Fiona joined, the team was over-indexed on creative generalists and under-indexed on deep systems people. Building Claude Code Remote required distributed-systems chops. Hire for the hard parts.
  • De-emphasized: raw coding throughput. Less leverage now that the models close that gap.

Cross-functional gap-filling.

  • Fiona’s content-design example: needed succinct survey-response copy; didn’t have a dedicated content designer; Claude became the content-design partner.
  • PMs on the CC team write code. Engineers do design work. Roles are blurring. The skill stack widens.

Org shape — flat, scrappy, every-manager-starts-as-IC.

  • Fiona pushed back hard on recruiters’ default “10 ICs to 1 manager, then start nesting” pattern.
  • Every manager starts as an IC to earn street cred + be an effective engineer. Recruiters thought “no manager would be interested in that.” Fiona’s bar: if not interested, better to separate early.
  • Flat = agile = adapts faster to shifting constraints.

Source of truth — code, not docs.

  • For Cloud Code, the code is the source of truth. Fiona answers customer questions with desktop Claude pointed at the local repos.
  • Prevents the lag where documentation drifts from implementation.
  • Caveat: do what makes sense for your team. If you have good specs, check them into the repo and have Claude verify code against them.

Rollout — what’s mandatory vs what’s enabled

Three team-wide principles (mandatory, but kept under review):

  1. Every CC team member uses Claude Code. Not just engineers — cross-functional partners too. They use Cowork heavily as well.
  2. Claudify everything you can. “What’s better than one of us doing it? Having Claude do it.” Always be looking for the next workflow that can be automated.
  3. Explicit permission to kill old processes. The most-frequently-cited one. Stand-ups → status spreadsheet → status skill the team runs. The process retires when it stops serving — but you have to give permission for that to happen.

What each pod adapts:

  • Triage process / how they use Claude in triage.
  • Planning rituals + stand-up format.
  • On-call handoff.
  • Which workflows to Claudify first.

Fiona’s principle: align on the must-do, enable autonomy on the how.

What success looks like — the three metrics

  • Onboarding ramp-up time. Dramatically reduced. New engineers, designers, PMs all become effective faster.
  • PR cycle time. Shortening. Double-click into this metric — if it stalls, it may reveal product-infrastructure or CI bottlenecks, not just AI-adoption gaps.
  • % Claude-assisted commits. Going up. Fiona: “I don’t think I’ve seen a non-Claude-assisted commit in probably the last four months.”

Beyond throughput — measure quality + reliability. “Sometimes you see headlines, ‘X% of code is now generated by AI.’ Throughput is great but it’s not the end goal. The end goal is: what product is more delightful for users? What problem is solved more reliably?”

Open questions Fiona is still working through

  • iOS vs Android org structure. When engineers can flex across mobile platforms more easily, does separate iOS + Android still make sense?
  • Fully automated review — how much? Where’s the balance between “fast enough” and “lost something important”? Trust-but-verify. And it’s a moving target — capability improvements may shift this every model release.
  • Roles blurring — do all team members feel equally productive? Bridging the gap between non-traditional coders and engineers as roles soften.

The closing audit prompt

Pick your noisiest workflow. Most-expensive, the one you dread, the one your team doesn’t look forward to. Ask: “is it still serving the purpose?”

Fiona’s example: a 50-person weekly review where everyone was on their laptops except when popping their head up to deliver their status. She asked “why are we having this?” — and the meeting got cancelled.

The bottleneck has moved

ThenNow
Engineering bandwidth was expensiveCoding rarely the slow part
Pre-planning expensive because coding wasJIT planning; design docs replaced by PRs
Refactoring time had to be scheduledRefactor is cheap; debt cleanup is opportunistic
Code review = humans, full readClaude handles style/lint/feedback; humans for risk + taste
6-month roadmap3-month max before staleness
Roles separated (engineer / PM / designer)Roles blurring; everyone codes some, everyone designs some
Source of truth = design doc / specSource of truth = code
”Who wrote this code?” = ownership”Who wrote this code?” = nuanced; double-click to the real question
Process layers stackExplicit permission to kill processes

Try It

  1. Run Fiona’s noisiest-workflow audit on your team this week. Pick the most-expensive recurring meeting or process. Ask “is this still serving?” Cancel one thing.
  2. Generate 3 PRs for your next architecture debate instead of going to a whiteboard. Have Claude render each option + show impact on callers. Time it against the would-have-been whiteboard session.
  3. Codify a status spreadsheet as a Claude skill. Anthropic’s CC team did exactly this. Replace your stand-up with a script Claude runs to summarize each engineer’s PR + Slack + commit activity. Measure: time saved per week + completeness of awareness.
  4. Split your code-review checklist into “Claude does / human does.” Move style + lint + PR-feedback + adding-tests to Claude. Keep legal + security + product-taste with humans. Measure: review cycle time before/after.
  5. Try the “every manager starts as IC” pattern on your next hire. Even if it’s just a 4-week IC ramp. The dogfooding case is concrete. The street-cred case is real.
  6. Watch your ”% AI-assisted commit” metric instead of ”% AI-generated lines.” Generating lines is a vanity metric. Commits being co-authored with Claude is a workflow metric.

Open Questions

  • The pre-AI bottleneck redistribution map. Fiona named planning, code ownership, code reviews, team makeup, knowledge-sharing as the rewritten norms — and verification, review, cross-functional partners, security as the new bottlenecks. The exhaustive map (what else shifted, what hasn’t shifted) isn’t in the talk.
  • Cross-org transfer. Anthropic’s Claude Code team has an unusually-deep dogfooding loop — the product they build is the product they ship. Which of Fiona’s principles transfer cleanly to a team building a non-AI product?
  • Onboarding ramp-up time — by how much? “Dramatically reduced” cited without a number.
  • PR cycle time — by how much? Same.
  • % Claude-assisted commits — what’s the baseline? “Probably last four months” since Fiona saw a non-Claude-assisted commit. What about earlier in the team’s lifetime?
  • Code-review trust boundary. Where exactly does the team trust Claude vs human? Fiona names legal + security + product taste as human-required. A complete rubric for routing reviews would be a connection-article-worthy artifact.

Graph View

Backlinks