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.
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
- Starts 31 interviews with buyers and users: current customers, lost deals and teams that never bought (scenario).
- Turns the interviews into weights; writes
positioning.py; runs the sensitivity test.
- Drafts the one-pager; the board debates a broader "general coding agent" strategy and rejects it (section 13).
- 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
- He uses Richard Rumelt's "kernel" of good strategy.
- A diagnosis: what is really going on, and what is the hardest part.
- A guiding policy: the overall approach to that hardest part.
- Coherent actions: a few steps that reinforce each other.
- Rumelt contrasts this with "bad strategy": goals dressed as strategy, fluff, and failing to face the main challenge.
- The diagnosis, in one paragraph.
- General coding agents from frontier labs are improving fast and are good enough for most code most of the time.
- Buyers with private, regulated code still hesitate, not because the agents are weak but because they cannot show auditors why each change is safe.
- Maestro's advantage is not a better general model; it is a model and a process that learn a customer's code under a gate that produces evidence.
- The guiding policy.
- Be the most trusted way to improve private, regulated codebases with AI, and let the general labs win the general market.
- The coherent actions.
- Sell to regulated mid-size companies first (section 8).
- Invest in environments and the skill library, not in winning public benchmarks (Phase 6).
- Make the gate's evidence part of the product (Phase 8).
3. The competition, in four groups
- Frontier labs.
- They ship coding and computer-use agents on a fast cadence. In October 2026 alone the site's tracker logged GPT-6.1 Terra (a cheaper computer-use model), Gemini 4 Argon reaching wide availability and Gemini 4 Carbon for security work, and Anthropic donating the Agent Skills standard to the Linux Foundation's Agentic AI Foundation.
- Strengths: model capability, distribution, money. Weakness for this market: one product for everyone, and limited ability to train on each customer's private code.
- Open-weight models with a do-it-yourself harness.
- Large open models such as Mistral Large 4 (weights released 29 October 2026) and Kimi K3.1 make it possible for a capable team to build its own agent.
- Strengths: price and control. Weakness: the customer has to build and maintain evaluation, safety and the harness.
- Developer-tool incumbents.
- Code hosting, IDE and CI vendors add agents to products buyers already pay for.
- Strengths: distribution and integration. Weakness: their agents are usually built on someone else's model and are general.
- Other specialists.
- Start-ups targeting one language, one industry or one task (tests, migrations, security fixes).
- They are the likeliest acquirers or acquisition targets, and occasionally partners.
Four competitor groups and what they have that Maestro does not
The groups are archetypes, not ratings of named companies.
4. What 31 buyers said (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.
- Who he talked to.
- Nine current customers, eight lost deals, eight teams that never evaluated Maestro, six that built their own agent on an open model.
- Each ranked their top three reasons for choosing an AI coding product, from a fixed list of six.
- How he turned answers into weights.
- A criterion's weight is the share of top-three mentions it received, normalised to 100%.
- He reports the weights with the number of interviews, because 31 is small: one more interview can move a weight by a few points.
What buyers ranked in their top three (scenario weights)
The weights in positioning.py.
- What surprised him.
- Lost deals cited "vendor will exist in three years" more than price: a start-up's risk is a real cost to buyers.
- Teams that built their own agent were the most interested in buying the evaluation and gate as a separate product (a seed for Phase 8's "harness as product").
5. Scoring the options
- Each option gets a 1โ5 score per criterion.
- Scores are Gopala's judgement of each archetype, argued in a team review and written down with reasons.
- Maestro scores low on "vendor will exist in three years" (2 of 5): honesty about the weakest point.
"""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()Weighted score by option (scenario)
Real output of positioning.py.
6. How narrow the lead is
- Maestro wins, but by 0.20 points out of 5.
- The sensitivity test raises one weight at a time (shrinking the others in proportion) until another option wins.
- What flips it.
- If raw model capability rises from 16% to 24% of what buyers care about, the frontier-lab agent wins.
- If "vendor will exist in three years" rises from 12% to 18%, the frontier lab wins again.
- If fitting existing tools rises from 14% to 29%, the same.
- Only a huge rise in price sensitivity (14% to 50%) makes the do-it-yourself option win.
- What never flips it.
- More weight on working with private code, or on evidence that each change is safe. Those are the criteria to make more important to buyers.
- The strategic reading.
- The company must keep buyers' attention on private code and evidence, where it is strong, and close the gap on durability and tool fit, where it is weak.
- It must not compete on raw capability: a few points of buyer attention there and the lead is gone.
- 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)
- Things to try.
- Push raw model capability to 25: the frontier lab takes the lead.
- Push evidence each change is safe to 35: Maestro's lead roughly doubles.
- Set price to 50 and everything else low: the do-it-yourself option wins, which is why Maestro does not sell to price-first buyers.
8. Where to play
- Bottom-up, not top-down.
- Investors distrust "1% of all developers" sizing. Gopala counts engineering teams he can actually reach, the share that fit (private code, regulated or security-sensitive) and a realistic price per team.
- All inputs below are our assumptions for the story, labelled as such.
"""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()Serviceable market by segment (our assumptions, $M a year)
Real output of market_size.py; about $1.15B a year in total.
- The choice.
- Regulated mid-size companies first: the highest price per team, the strongest need for evidence, and sales cycles a small team can manage.
- Large enterprises second, once security reviews and private deployments are ready (Phase 8).
- Scale-ups opportunistically: they buy fast but care most about raw capability and price, where Maestro is weakest.
- The three-year number.
- Winning 4% of the serviceable market would be about $46M of ARR: a target to test, not a forecast.
9. How to win: the moat in plain words
- Not the weights.
- Open models catch up within months, and frontier labs spend more on one run than the whole Series A.
- What compounds.
- The skill library: verified skills from every customer task, kept per customer under the data agreements.
- Environments: thousands of runnable task environments with checks, which are expensive to build and improve every model (Phase 6, Part 8).
- The gate's record: years of approved and rejected updates with reasons, which auditors and buyers can inspect.
- Integrations and trust with regulated customers, which take quarters to earn.
- In Hamilton Helmer's "7 Powers" terms.
- Switching costs: a customer's skills and evaluation history live in Maestro.
- Process power: the gate and evaluation machinery are hard to copy quickly.
- Counter-positioning: a general lab is unlikely to make every update wait for customer-specific evidence, because it would slow its own release cadence.
The flywheel that is the moat
Each turn makes the next customer easier to win and harder to lose.
10. What we will not do
- The list that makes the strategy real.
- No general consumer coding assistant.
- No competing on public coding leaderboards as a sales message.
- No training on one customer's code for another customer's model.
- No loosening the gate to match a competitor's release cadence.
- No price war with open-model do-it-yourself teams.
- No custom consulting projects that do not produce reusable skills or environments.
- No exclusive deals with a single cloud provider (S2 Part 1).
- Each item has a reason and an owner.
- When a big deal tempts the company to break one, the owner writes why, and the board decides.
11. Three bets, each with a kill criterion
| Bet | What would prove it | Kill criterion (by month 30) |
|---|---|---|
| Regulated mid-size is the beachhead | 20 customers in finance and health; NRR above 120% on the first two cohorts | Fewer than 8 new regulated customers by month 30 |
| Environments are the next moat | Each 1,000 new environments improves Maestro on held-out customer tasks | No measurable gain from two successive batches (Phase 6) |
| Evidence sells | Buyers cite the gate record as a top-three reason in win reviews | Cited in fewer than a quarter of wins |
- Why kill criteria again.
- Season 1, Part 1 wrote kill criteria for the idea; Season 2 writes them for the strategy. A bet without one is a hope.
12. The page itself
- 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)
- 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.
- How it was settled.
- The independent director asked for a test, not an argument: run both messages in parallel to 40 prospects for six weeks.
- The specialist message converted about twice as often in the story's test; the board accepted the strategy with a review at month 30.
- What Gopala conceded.
- A self-serve trial for scale-ups, with no sales effort, to keep an eye on the general market.
14. What the strategy means for pricing
- Price on the outcome the strategy emphasises.
- Season 1's hybrid pricing (Part 16): a platform fee plus a price per accepted task. The strategy keeps it, because it ties revenue to work customers accept, not to tokens.
- An evidence tier.
- Regulated customers pay more for an audit package: the gate record for every update applied to their account, exportable for auditors.
- It makes the strongest criterion in the interviews (evidence) visible on the price list.
- No race to the bottom.
- The sensitivity test said only extreme price sensitivity makes the do-it-yourself option win. Price-first buyers are not the target, so Maestro does not discount to win them.
- The self-serve trial.
- A limited free tier for scale-ups (section 13), capped by tasks per month, as a window on the general market rather than a revenue line.
15. Build, buy or partner
- What Maestro builds itself.
- The model and the self-improvement loop, the gate and evaluation machinery, the skill library and environments: everything on the moat list.
- What it buys.
- Compute, observability, identity and billing systems, sandboxes where a good product exists (see Agent Layer Part 2).
- Where it partners.
- Code hosting and CI vendors, for integrations and marketplace listings (Phase 9).
- Systems integrators that serve regulated industries.
- The open question for Phase 8.
- Should customers be able to run Maestro's harness and gate with other labs' models? It could widen the market and weaken the model moat. The strategy leaves it open with a test date (S2 Part 17).
16. Strategy risks and early warnings
| Risk | Early warning | Response |
|---|---|---|
| A frontier lab launches a private-code product with per-customer training | Customers ask for side-by-side trials | Lean on the gate record and audit package; accelerate the evidence tier |
| An open model closes the capability gap at a fraction of the price | Do-it-yourself teams win more trials | Post-train the open base (Phase 7 option); sell the harness |
| Regulation makes evidence mandatory | Auditors ask for change records | An opportunity: the product already produces them |
| Incumbents bundle a good-enough agent free | Lost deals cite "already have one" | Deeper integrations; partner rather than fight |
| The beachhead is too small | Fewer than 8 regulated wins by month 30 (kill criterion) | Re-run market_size.py; move to large enterprise earlier |
- Who watches them.
- Each risk has an owner and appears in the board's risk register every quarter (S2 Part 4).
17. Eight strategy mistakes
- Writing goals ("be the leader") and calling them a strategy.
- Choosing the biggest market instead of the one you can win.
- Scoring yourself without scoring your weakest criterion honestly.
- Ignoring the sensitivity test: a lead that one weight can erase is not a moat.
- Treating model weights as the moat.
- A "not do" list with no owner, broken by the first big deal.
- Bets without kill criteria.
- Sharing the strategy as a deck instead of one page everyone can quote.
18. Delegation box
- The diagnosis, guiding policy and the not-do list
- The board debate and the test design
- Final scores, argued in review
- Transcribing and coding the 31 interviews for him to check
- Running
positioning.pyandmarket_size.pyvariants - Competitor release tracking
- 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
| Item | Status after Part 3 | Note |
|---|---|---|
| Strategy | One page, shared with the company | Review at month 30 |
| Positioning lead | 0.20 of 5 (scenario) | From positioning.py |
| Serviceable market | ~$1.15B a year (our assumptions) | From market_size.py |
| Competition risk | High | Lead flips if capability weight rises 8 points |
| Durability perception | Watch | Weakest criterion (2 of 5) |
| Focus risk | Lower | Board accepted the specialist strategy |
20. The series
The Maestro, Season 2: 23 parts in five phases (Season 1: 18 parts)
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.