Home โ€บ Blog โ€บ The Maestro, Season 2 ยท Part 3
The Maestro, Season 2 ยท Part 3 ยท Phase 5 ยท ๐Ÿงญ CEO hat

The Strategy One-Pager

Money and people are not a strategy. Before the new team starts building, Gopala writes one page that says where the company plays, how it wins, and what it will not do, against three kinds of competitor that are all larger: frontier labs shipping coding agents every few months, open-weight models with do-it-yourself harnesses, and developer-tool incumbents adding AI to products buyers already have. This part builds that page from 31 customer interviews, a scoring script with a sensitivity test that shows how narrow the lead is, a bottom-up market size, the moat in plain terms, three bets with kill criteria, and the list of things the company refuses to do.

FL
FrontierAGI Team
๐Ÿ’ผ CEO๐Ÿงญ Strategist๐Ÿ“Š Analyst๐Ÿ—ฃ๏ธ Customer researcher
โš ๏ธ How to read this (as of 2 Nov 2026) positioning.py and market_size.py were run (real output below). Interview results, weights, scores and market inputs are the story's scenario or our assumptions; competitor archetypes are generic, not ratings of real companies. Real product releases are cited from the site's Frontier Lab Updates. Gopala and his company are a teaching story. Disclosure: Claude, made by Anthropic, helps write this site.

1. Mission log: months 22โ€“24

Week 92 ยท Interviews
  • Starts 31 interviews with buyers and users: current customers, lost deals and teams that never bought (scenario).
Week 95 ยท The scoring
  • Turns the interviews into weights; writes positioning.py; runs the sensitivity test.
Week 97 ยท The page
  • Drafts the one-pager; the board debates a broader "general coding agent" strategy and rejects it (section 13).
Week 98 ยท Shared
  • Reads the page to the whole company; every team writes its quarterly goals against it (S2 Part 4).

2. Strategy in one page: diagnosis, policy, actions

3. The competition, in four groups

Four competitor groups and what they have that Maestro does not

๐Ÿ›๏ธFrontier labscapability, distribution
๐ŸงฉOpen model + DIYprice, control
๐ŸงฐTool incumbentsalready installed
๐ŸŽฏSpecialistsfocus on one niche

The groups are archetypes, not ratings of named companies.

4. What 31 buyers said (scenario)

Scenario
  • The interviews, the people in them and every weight below are the story's. The method, top-three mentions turned into weights, is a simple and common way to summarise buyer interviews.

What buyers ranked in their top three (scenario weights)

Works on our private code24%
Evidence each change is safe20%
Raw model capability16%
Price per task14%
Fits our tools today14%
Vendor will exist in 3 years12%

The weights in positioning.py.

5. Scoring the options

positioning.py ยท Python 3, no dependencies; scenario weights and scores
"""positioning.py โ€” how four kinds of option score on what buyers said matters.

Weights come from the story's 31 SCENARIO customer interviews (share of
buyers who ranked the criterion in their top three, normalised). Scores
(1-5) are Gopala's own judgement of each archetype, not measurements of
any real company. The sensitivity test asks: how far must one weight move
before Maestro stops winning?
"""
CRIT = ["works on our private code", "evidence each change is safe", "raw model capability",
        "price per task", "fits our tools today", "vendor will exist in 3 years"]
W = [0.24, 0.20, 0.16, 0.14, 0.14, 0.12]
OPTS = {
    "Maestro (specialist)":        [5, 5, 3, 4, 3, 2],
    "frontier-lab coding agent":   [3, 3, 5, 3, 4, 5],
    "open model + DIY harness":    [4, 2, 3, 5, 2, 3],
    "dev-tool incumbent add-on":   [2, 3, 3, 3, 5, 5],
}

def score(w):
    return {k: sum(a * b for a, b in zip(w, v)) for k, v in OPTS.items()}

def main():
    s = score(W)
    for k, v in sorted(s.items(), key=lambda x: -x[1]):
        print(f"{k:28} {v:.2f}")
    print("sensitivity: weight increase (others shrink in proportion) that makes Maestro lose")
    for i, c in enumerate(CRIT):
        for step in range(1, 101):
            w = [x * (1 - step / 100) for x in W]
            w[i] = W[i] + (1 - W[i]) * step / 100
            w = [x / sum(w) for x in w]
            r = score(w)
            best = max(r, key=r.get)
            if best != "Maestro (specialist)":
                print(f"  {c:30} {W[i]:.2f} -> {w[i]:.2f}  {best} wins"); break
        else:
            print(f"  {c:30} never")

if __name__ == "__main__":
    main()
$ python3 positioning.py # scenario interviews; archetype scores Maestro (specialist) 3.90 frontier-lab coding agent 3.70 dev-tool incumbent add-on 3.28 open model + DIY harness 3.18 sensitivity: weight increase (others shrink in proportion) that makes Maestro lose works on our private code never evidence each change is safe never raw model capability 0.16 -> 0.24 frontier-lab coding agent wins price per task 0.14 -> 0.50 open model + DIY harness wins fits our tools today 0.14 -> 0.29 frontier-lab coding agent wins vendor will exist in 3 years 0.12 -> 0.18 frontier-lab coding agent wins

Weighted score by option (scenario)

Maestro (specialist)3.90
Frontier-lab coding agent3.70
Dev-tool incumbent add-on3.28
Open model + DIY harness3.18

Real output of positioning.py.

6. How narrow the lead is

Rule from the sensitivity test
  • Every product and marketing decision is checked against one question: does it make private-code results and change-by-change evidence matter more to buyers, or does it pull the comparison towards raw capability?

7. Try it: change what buyers care about

Positioning scores (our model, same numbers as positioning.py)

8. Where to play

market_size.py ยท Python 3, no dependencies; all inputs are assumptions
"""market_size.py โ€” bottom-up market sizing, the way investors check it.

Every input is OUR ASSUMPTION for the story (labelled on the page), not a
market statistic: we count teams Gopala can actually reach, not 'all developers'.
"""
SEGMENTS = [  # segment, companies, engineering teams each, share that fit (private code, regulated), $k per team per year
    ("regulated mid-size (finance, health)", 6000, 8, 0.30, 36),
    ("large enterprise", 1500, 60, 0.15, 30),
    ("software scale-ups", 12000, 4, 0.20, 24),
]
REACH_3Y = 0.04      # share of the fitting market a 40-person company can win in three years (assumption)

def main():
    tot = 0
    for name, n, teams, fit, price in SEGMENTS:
        v = n * teams * fit * price / 1000
        tot += v
        print(f"{name:38} {n * teams * fit:9,.0f} teams  ${v:7,.0f}M/yr")
    print(f"{'serviceable market':38} {'':15}  ${tot:7,.0f}M/yr")
    print(f"3-year target at {REACH_3Y:.0%} of it:            ${tot * REACH_3Y:7,.1f}M ARR")

if __name__ == "__main__":
    main()
$ python3 market_size.py # our assumptions, not market statistics regulated mid-size (finance, health) 14,400 teams $ 518M/yr large enterprise 13,500 teams $ 405M/yr software scale-ups 9,600 teams $ 230M/yr serviceable market $ 1,154M/yr 3-year target at 4% of it: $ 46.2M ARR

Serviceable market by segment (our assumptions, $M a year)

๐Ÿฆ Regulated mid-size ยท $518M14,400 fitting teams in finance and health, about $36k per team a year
๐Ÿข Large enterprise ยท $405M13,500 fitting teams, about $30k per team
๐Ÿš€ Software scale-ups ยท $230M9,600 fitting teams, about $24k per team

Real output of market_size.py; about $1.15B a year in total.

9. How to win: the moat in plain words

The flywheel that is the moat

๐Ÿง‘โ€๐Ÿ’ปCustomer taskreal work on private code
โœ…Verified skillchecked by tests and reviewers
๐Ÿ—๏ธEnvironmentturned into a runnable check
๐ŸšฆGate recordevery update with evidence
๐ŸคTrustmore tasks shared

Each turn makes the next customer easier to win and harder to lose.

10. What we will not do

11. Three bets, each with a kill criterion

BetWhat would prove itKill criterion (by month 30)
Regulated mid-size is the beachhead20 customers in finance and health; NRR above 120% on the first two cohortsFewer than 8 new regulated customers by month 30
Environments are the next moatEach 1,000 new environments improves Maestro on held-out customer tasksNo measurable gain from two successive batches (Phase 6)
Evidence sellsBuyers cite the gate record as a top-three reason in win reviewsCited in fewer than a quarter of wins

12. The page itself

Maestro strategy, month 22 (one page)
  • Diagnosis.
    • General agents are good enough for most code; regulated teams cannot prove each change is safe.
  • Guiding policy.
    • The most trusted way to improve private, regulated codebases with AI.
  • Where we play.
    • Regulated mid-size first, then large enterprise; scale-ups opportunistically.
  • How we win.
    • Skills, environments and the gate's record; switching costs and process power.
  • What we will not do.
    • Seven items, section 10.
  • Bets and kill criteria.
    • Three, section 11.

13. The board debate (scenario)

Scenario
  • At the month-23 board meeting the Series A partner argues for a broader "general coding agent for every team", pointing at the market size. Gopala answers with the sensitivity test: in the general market, raw capability matters more, and that is where the lead disappears.

14. What the strategy means for pricing

15. Build, buy or partner

16. Strategy risks and early warnings

RiskEarly warningResponse
A frontier lab launches a private-code product with per-customer trainingCustomers ask for side-by-side trialsLean on the gate record and audit package; accelerate the evidence tier
An open model closes the capability gap at a fraction of the priceDo-it-yourself teams win more trialsPost-train the open base (Phase 7 option); sell the harness
Regulation makes evidence mandatoryAuditors ask for change recordsAn opportunity: the product already produces them
Incumbents bundle a good-enough agent freeLost deals cite "already have one"Deeper integrations; partner rather than fight
The beachhead is too smallFewer than 8 regulated wins by month 30 (kill criterion)Re-run market_size.py; move to large enterprise earlier

17. Eight strategy mistakes

18. Delegation box

๐Ÿ™‹ Gopala himself
  • The diagnosis, guiding policy and the not-do list
  • The board debate and the test design
  • Final scores, argued in review
๐Ÿค– AI agents
  • Transcribing and coding the 31 interviews for him to check
  • Running positioning.py and market_size.py variants
  • Competitor release tracking
๐Ÿค Bought, rented or borrowed
  • A strategy adviser who ran a developer-tool company
  • Interviewees' time (with thanks and a summary sent back)
  • Market data where available

19. Budget and risk tracker

ItemStatus after Part 3Note
StrategyOne page, shared with the companyReview at month 30
Positioning lead0.20 of 5 (scenario)From positioning.py
Serviceable market~$1.15B a year (our assumptions)From market_size.py
Competition riskHighLead flips if capability weight rises 8 points
Durability perceptionWatchWeakest criterion (2 of 5)
Focus riskLowerBoard accepted the specialist strategy

20. The series

The Maestro, Season 2: 23 parts in five phases (Season 1: 18 parts)

VerdictThe strategy fits on one page because it is a set of choices: play where private code and evidence matter, win with skills, environments and the gate's record, and refuse the markets where raw capability decides. The scoring script shows the lead is real but narrow, which is the most useful thing it says. Next: the operating cadence that turns the page into weekly work.

21. Reading the numbers

Primary / standard
Rumelt's kernel of strategy; Helmer's 7 Powers; real releases from the site's Frontier Lab Updates.
Secondary โš ๏ธ
None in this part.
Our assumptions
Interviews, weights, scores, market inputs, the board test and its result are scenario or our assumptions.