Skip to content

Architecture

The reference architecture of an AI-native Product Development Lifecycle: a data/context foundation, a knowledge-and-artifact platform above it, a governed AI agent embedded in each lifecycle phase, and execution tools wired end-to-end through explicit gates. The layering is inferred from converging disclosures — principally Freshworks — and then mapped against the public productizations (GitHub Spec Kit, AWS Kiro) that package the same shape for everyone else.

Evidence Strata

  • [F] Freshworks-reported from the flagship disclosure: the episode writeup, the full video, and the author's deck. Unauditable single-vendor narrative.
  • [P] Publicly reproducible: Spec Kit repository/docs (verified directly), Kiro docs.
  • [A] Our analytical extension. Internal implementation gaps carry TBD markers; external career/financial facts are cross-verified in index sources.

Reference Architecture

flowchart TB
    subgraph DF["Layer 0: Data-First Foundation"]
        direction LR
        DS["Agent-Parseable<br/>Design System"]
        CS["Explicit Written<br/>Standards/Rules"]
        REPO["Single Source-of-Truth<br/>Repository"]
        CONST["Project Constitution<br/>(governing principles)"]
    end

    subgraph PLAT["Layer 1: Knowledge & Artifact Platform"]
        direction LR
        KH["Knowledge Hub<br/>product graph + dependencies"]
        CH["Context Hub<br/>state threaded between phases"]
        AR["Artifact Library<br/>skills / rules / commands / templates"]
    end

    subgraph PDLC["Layer 2: Phase-Gated Lifecycle"]
        direction LR
        P1["Requirements"] --> P2["Clarify"] --> P3["Plan / PRD"] --> P4["Design"] --> P5["Prototype"] --> P6["QA / Evals"] --> REL["Release Train"]
    end

    AG["Governed Phase Agent<br/>one per phase"]

    subgraph TOOLS["Layer 3: Execution Tools (swappable)"]
        direction LR
        ED["Agentic IDE / CLI<br/>(Cursor, Kiro, Claude Code ...)"]
        UI["Prototyping Surface<br/>(e.g. Figma Make)"]
        WH["Grounding Warehouse<br/>(e.g. Databricks 'Bel')"]
    end

    DF --> PLAT
    PLAT --> PDLC
    TOOLS --> PDLC
    AG -.->|"every phase"| P1
    AG -.-> P3
    AG -.-> P6

    classDef foundation fill:#e8f0fe,stroke:#1a73e8,color:#174ea6
    classDef platform fill:#fef7e0,stroke:#f9ab00,color:#7c5000
    classDef lifecycle fill:#e6f4ea,stroke:#188038,color:#0d652d
    classDef tooling fill:#f3e8fd,stroke:#a142f4,color:#6a1da8
    classDef gov fill:#fce8e6,stroke:#d93025,color:#a50e0e

    class DS,CS,REPO,CONST foundation
    class KH,CH,AR platform
    class P1,P2,P3,P4,P5,P6,REL lifecycle
    class ED,UI,WH tooling
    class AG gov

The dependency direction is the doctrine's core claim [F]: teams fail when they invert it ("open Cursor, start prompting") because Layer 2 without Layers 0-1 has nothing trustworthy to stand on — at Freshworks' stated 300M-end-user scale, hallucination tolerance is zero.

Instance Mapping

Same roles, three vocabularies:

Pattern Role Freshworks instance [F] Spec Kit analogue [P] AWS Kiro analogue [P]
Governing principles Prism knowledge hub + written coding standards /speckit.constitution -> constitution-template.md Reviewed requirement documents
Requirements artifact Idea brief -> PRD (phase 1-N) /speckit.specify -> spec-template.md requirements.md in EARS notation
Interrogation gate Agent asks persona/drill-down/success questions before building /speckit.clarify (recommended before plan) Requirement review before design
Context between phases Prism context hub .specify/ artifacts + agent file hand-off Spec files as contract across phases
Consistency check CPO Check (human persona gate) /speckit.analyze cross-artifact analysis Design review vs requirements
Quality checklist Evals phase [mechanism TBD] /speckit.checklist — "unit tests for English" Acceptance criteria embedded per story
Execution Prototype -> QA inside 12-phase run /speckit.implement Parallel task agents + hooks/tests
Grounding data Bel Databricks lake, agent-written SQL shown in-PRD Nothing prescribed — bring your own [gap] Existing codebase as design grounding

Reading The Gaps

Two asymmetries are analytically load-bearing. First, grounding ([Bel]-style warehouse access) has no analogue in the open tooling yet — anyone adopting Spec Kit must build that integration themselves. Second, human authority gates (CPO Check) exist in the enterprise narrative but only as culture in the mandates — the tooling encodes consistency checks, not accountability.

Spec-Driven Instantiation [P]

Spec Kit materializes the lifecycle as an artifact chain with named commands installed into any of its 30+ supported agents:

flowchart LR
    INIT["specify init<br/>--integration <agent>"] --> CON["/speckit.constitution<br/>principles"]
    CON --> SPEC["/speckit.specify<br/>what & why"]
    SPEC --> CLA["/speckit.clarify<br/>underspecified areas"]
    CLA --> PLAN["/speckit.plan<br/>tech stack & architecture"]
    PLAN --> ANA["/speckit.analyze<br/>cross-artifact coverage"]
    ANA --> TASKS["/speckit.tasks<br/>actionable breakdown"]
    TASKS --> CHK["/speckit.checklist<br/>requirements tests"]
    CHK --> IMP["/speckit.implement"]
    IMP -.->|"brownfield loop"| CON

    classDef cmd fill:#e6f4ea,stroke:#188038,color:#0d652d
    class CON,SPEC,CLA,PLAN,ANA,TASKS,CHK,IMP cmd

Kiro reaches the same triad with heavier formalism: acceptance criteria written in EARS (Easy Approach to Requirements Syntax) — e.g. "WHEN usage drops 20% week-over-week THE SYSTEM SHALL surface the affected accounts ranked by MRR" — chosen precisely because constrained syntax makes criteria testable by agents rather than merely readable.

Case Study: Freshworks (flagship disclosure)

The deepest single narrative available; all details vendor-narrated.

Layer 0 Foundation [F]

Component Role Failure mode it prevents
Agent-parseable design system Tokens/components machine-readable; feeds Figma Make prompts Generators inventing or silently skipping components (observed live: Figma Make skipped some — declared residual-human territory)
Written coding standards Ingestible rules instead of tribal norms Style drift across concurrent sessions
Single monorepo One canonical codebase Forked realities between docs, prototypes, shipped code

Prism Platform [F]

Three declared parts — knowledge hub (product + dependencies), context hub (per-feature state threaded across phases), and the AI builder artifacts library (skills/rules/commands/agents encoding how Freshworks builds):

flowchart LR
    KB["Knowledge Hub"] -->|"grounding"| RUN["Phase Agents at runtime"]
    CTX["Context Hub"] <-->|"read/write phase state"| RUN
    ART["Artifact Library"] --> RUN
    RUN --> HARN["12-Phase Harness Run"]

    classDef store fill:#fff4ce,stroke:#f9ab00,color:#7c5000
    classDef runtime fill:#e6f4ea,stroke:#188038,color:#0d652d
    class KB,CTX,ART store
    class RUN,HARN runtime

Harness Flow [F]

Entry via Cursor slash command /fw-innit (collects business unit, Epic ID, feature team), deliberately model-agnostic — demoed on Grok ("Nothing takes more than 10-15 seconds"; "No Claude Code or Codex. Just Cursor + any model"):

sequenceDiagram
    autonumber
    actor PM as Builder (Product Builder)
    participant CUR as Cursor + /fw-innit harness
    participant PH as Phase Agent
    participant PZ as Prism (context hub)
    participant BEL as Bel (Databricks)
    participant CP as CPO Check gate
    participant FIG as Figma Make
    participant EV as Evals Phase

    PM->>CUR: "/fw-innit"
    CUR->>PM: ask business unit, Epic ID, feature team
    CUR->>PH: launch up to 12 phases (idea brief ... prototyping, QA)
    PH->>PM: clarifying questions a good PM would ask
    PM-->>PH: answers in plain English
    PH->>PZ: pull product knowledge + prior phase context
    PZ-->>PH: grounded facts
    PH->>BEL: write SQL against usage telemetry
    BEL-->>PH: quantitative results (demo: 4,358 active ITSM accounts)
    PH->>PH: assemble PRD, evidence shown inline
    PH->>CP: draft submission
    CP->>CP: review the way Srini would (gate named after him)
    CP->>FIG: approved PRD
    FIG->>FIG: prototype against parseable design system
    FIG-->>EV: working prototype
    EV->>CUR: pass/fail feeds biweekly release train

Reported Outcomes And Benchmarks [F unless marked x]

All rows vendor-reported (single recorded session + one live demo); no independent benchmark exists. Company figures marked (x) externally verified; figures marked m are marketing claims.

Metric Before After Type Conditions
Release cadence Every 6 months Every 2 weeks v Whole-PDLC change under one CPO tenure (Dec 2024 - mid 2026)
Staffing ratio 1 PM + 1 designer : 10-20 engineers 1 PM : 1 engineer; some teams no dedicated designer v Org of 200+ titled PM/designer/researcher staff
Agent round-trip latency n/a <= 10-15 s per step v Live demo on Grok models in Cursor
Evidence sweep in demo PRD n/a 4,358 active ITSM accounts aggregated v EX Agent Studio performance dashboard feature
FY2026 revenue at recording — ~$960M guidance x Later raised twice to $963.5M-$966.5M (~15% YoY)
Customer/end-user scale — 75,000+ customers, 300M end users m Long-standing company marketing figure

Context caveats from the same period [x]: headcount "~4,000" follows an announced ~500-person (~11%) restructuring; stock declined ~32% during 2026. Efficiency narrative and cost-cutting share a timeline — read both together.

TBD: names/purposes of all 12 phases beyond endpoints; evals-suite composition; per-run cost/token envelope; whether ratio targets survived the mid-2026 transition to a merged CPTO role.

Structural Risks (class-level)

Summarized here, threat-modeled properly in security:

  1. Artifact rot — stale skills/rules degrade every downstream phase simultaneously, unlike document rot which degrades only readers.
  2. Silent generator omission — demonstrated by the disclosed Figma Make skips; mitigations must enumerate from ground truth (design system), not prompts.
  3. Gate keying to individuals — "CPO check" was literally named after one executive who left months later.
  4. Mandate/process decoupling — orgs can order substitution (mandates) without shipping machinery; velocity claims then rest on unstructured usage.

Sources