The build journal

From day one.
Still building.

A chronological record of how a small ideation experiment is becoming an AI-native platform — including the foundations and changes of ambition that made the next step possible.

16documented
build days
01 The story so far
01
Day one

From a blank repository to a working ideas product

The first version established the basic loop: capture ideas, develop them with AI, compare possibilities and turn the strongest thinking into a roadmap.

  • Created the application and API structure
  • Built ideas, comparison and roadmap experiences
  • Connected generated API clients
  • Explored early visual directions
The decision was to build the whole learning loop, not just another suggestion box.
02
Day two

Making comparison useful, not just interesting

The focus moved to evidence and decisions: stronger comparison flows, relationship data and results that could leave the system as a useful CSV.

  • Expanded the comparison engine
  • Added CSV export from results
  • Introduced record relationships
  • Regenerated schemas and API clients
A product becomes more credible when users can take the result away and do something with it.
03
Day three

Context, agents and the first real architecture

The ideas tool started becoming a platform. Agents gained clearer responsibilities, comparisons became transitive and context could travel with ideas.

  • Refined chief and ideation agents
  • Added context management
  • Protected graphs from circular failures
  • Documented the architecture and migration
The project stopped looking like one feature and started looking like a system.
04
Measuring the machines

Making AI usage visible

The platform began recording model consumption and exposing usage to administrators.

  • Added AI usage events
  • Captured Anthropic consumption
  • Created usage APIs
  • Extended administration views
Autonomy without measurement is a creative way to lose control of a budget.
05
Organising access

From individual users to real organisations

The system gained organisation membership, audit events and a more repeatable deployment model.

  • Built organisation access
  • Added audit events
  • Expanded workspace navigation
  • Hardened Docker deployment
The platform must know who you are and which hat you are wearing.
06
Richer records

Profiles, attributes and fields that fit the work

Profiles, custom attributes and numeric fields made the model less rigid.

  • Added user profiles
  • Created custom attributes
  • Added numeric inputs
  • Connected profile context
Not everybody’s data looks exactly like yours.
07
Guardrails

Stopping accidental work from disappearing

Editing flows gained draft states and warnings before unfinished changes were discarded.

  • Added unsaved-change guards
  • Connected navigation warnings
  • Clarified save behaviour
  • Made drafts explicit
A tiny warning can save a large amount of inventive vocabulary.
08
Showing the answer

A reusable visualisation layer

A shared presentation model separated the meaning of data from how it was displayed.

  • Created a visualisation library
  • Defined presentation controls
  • Separated data from output
  • Prepared reusable views
The best visualisation makes a complicated relationship obvious.
09
Making views recognisable

Presentation became part of the model

Presentation language and icon treatment made configurable views feel deliberate.

  • Added presentation iconography
  • Aligned view types
  • Improved output cues
  • Prepared multiple modes
Configurable does not have to mean visually anonymous.
10
Context everywhere

Records learned how to explain themselves

Generic headings, formatting and relationship panels gave every object consistent context.

  • Built relationship panels
  • Added context headings
  • Centralised formatting
  • Reduced idea-specific code
A record’s relationships are usually where the story lives.
11
The model editor

Letting the platform describe new products

Model services and drag-and-drop editors replaced more hard-coded ideation behaviour.

  • Added metadata services
  • Built designer foundations
  • Created shared model hooks
  • Refined agent roles
The platform began learning how to assemble an answer.
12
Work that comes back

Workflow notifications arrived

Scheduled notifications made approvals and outstanding work visible and actionable.

  • Created notification scheduling
  • Added notification APIs
  • Built the notification workspace
  • Connected workflow states
A quiet workflow is often not finished; it is merely lost.
13
The platform turn

Replacing fixed screens with configurable building blocks

Objects, fields, collections, relationships and visualisations became reusable platform capabilities rather than code tied to ideas alone.

  • Created metadata-driven object models
  • Built design-system foundations
  • Added organisation and workspace concepts
  • Introduced configurable views
The ambition changed from building one app to building the machinery that can create many useful apps.
14
Designing the work

Views, workflows and a platform people can shape

Page designers, view builders, workflow approvals, notifications and administration moved into the product itself.

  • Built page and view designers
  • Added workflows and approvals
  • Introduced platform blueprints
  • Expanded user and usage administration
Configuration only becomes a product when it is understandable, previewable and safe to change.
15
Today’s direction

Building the organisation that builds the platform

User requests can enter a structured queue and specialist agents can investigate, plan, build and test changes inside a controlled environment.

  • Added scheduled Codex work
  • Separated agent responsibilities
  • Introduced controlled approvals
  • Connected demand to enhancement work
The goal is an organisation of agents with clear jobs, bounded authority and evidence at every hand-off.
16
Opening the workshop

Giving the work a public home

Product Agility gained its public story, platform holding page, cPanel packages and a documented brand system.

  • Created .co.uk and .app sites
  • Built cPanel packages
  • Applied Poppins and brand colours
  • Created a production logo suite
Building in public starts with explaining the work clearly.
02 What comes next

The notes continue as
the platform learns.

New entries will follow the work: what changed, why it mattered and what it taught me about building products with agents.

Visit the platform holding page ↗