Agus Tonna

Not a slide about AI. Working software.

I build the first version of a tool on a real problem myself. Then the team takes it over and extends it. That is how a product organisation becomes AI-native: by example first, then by everyone.

How I build with AI

At work

Voice-of-Customer Portal

Form live in the app · triage not running

A feedback form members reach in the app, with an LLM triage and clustering step designed behind it.

LLM pipelineembeddings

Every entry graded before it counts

  • Sample entry — describes a specific problem and when it happens kept
  • Sample entry — rating only, no words dropped
  • Sample entry — restates an earlier entry dropped
  • Sample entry — names the step where the user gave up kept

Grouped by meaning, not keyword

Sign-up frictionDiscoveryRedemptionBilling questionsCoverage requests

Bubble size shows relative cluster size. Sample themes.

Schematic recreation with synthetic data — not a product screenshot.
Schematic recreation of a voice-of-customer pipeline: a quality gate and embedding clusters.
Schematic recreation with synthetic data — not a product screenshot.

At work

Roadmap Copilot

Used mainly by product

Planning tool that keeps strategy and delivery in one view, with partner-facing items flagged explicitly rather than guessed.

Next.jsPostgresClaude Code

Now

  • SAMPLE-101

    Sample initiative — onboarding rebuild

    Activation

  • SAMPLE-104

    Sample initiative — billing clarity

    Retention

Next

  • SAMPLE-112

    Sample initiative — discovery surface

    Engagement

  • SAMPLE-118

    Sample initiative — referral loop

    Acquisition

Later

  • SAMPLE-130

    Sample initiative — partner tooling

    Supply

Schematic recreation with synthetic data — not a product screenshot.
Schematic recreation of a roadmap tool showing Now, Next and Later lanes with linked sample tickets.
Schematic recreation with synthetic data — not a product screenshot.

On my own timeIn use

LernDeutsch

German-learning PWA in daily use: Leitner spaced repetition, speech practice, offline-first.

Next.jsTypeScriptAnthropic APIClaude Code

Leitner boxes

  1. Box 1daily
  2. Box 2every 3 days
  3. Box 3weekly
  4. Box 4fortnightly
  5. Box 5monthly

Choose a card

die Verantwortung

Answer

responsibility

Correct → moves to Box 3 (weekly)

der Anspruch

Answer

claim, standard

Correct → moves to Box 2 (every 3 days)

nachhaltig

Answer

sustainable

Correct → moves to Box 5 (monthly)

die Entscheidung

Answer

decision

Correct → moves to Box 4 (fortnightly)

Interactive demo with sample vocabulary — a simplified version of the real app's Leitner scheduling.
Interactive demo of Leitner spaced repetition: pick a card to see its translation and which box it moves to.
Interactive demo with sample vocabulary — a simplified version of the real app's Leitner scheduling.

What I switched off

I specified a way for people outside the data team to ask our numbers questions in plain language, and wrote the acceptance tests. When we graded it on real questions, most answers were right; the misses came from definitions we hadn’t written down. I signed it off anyway, expecting use to close the gaps. Instead, people read its answers as fact. We paused it. Definitions before tools.

Lab

Things I'm building on my own time. Not in daily use yet, and labelled for what they are.

Prototype

Proc

Shows what needs you, when it needs you, and stays out of the way otherwise.

How Proc works

Design render with invented data: a Mac desktop with a planning document open. Proc shows a call starting in two minutes at the top, three messages waiting for a reply down the right, a timer top left, two blocked items and a summary of the day bottom left, and recent actions bottom right.
Concept view of the prototype with invented data, a fictional company, people and deals. Not a screenshot.

How I build with AI

Tools are the easy part. These are the rules I learned by getting them wrong.

  1. Review what the agent removed, not just what it added.

    I asked a coding agent to fix a feedback digest that looked broken. The rebuild report showed it had worked all along, and the rebuild had quietly switched it from daily to weekly and dropped anomaly detection. I kept the original, and cadence became a product decision instead of a side effect.

  2. Definitions before tools.

    A model that answers questions about the numbers is only as right as the definitions under it, and people read its answers as fact. Write the definitions down before anyone gets access.

  3. Constrain the summary.

    An AI digest that turns three complaints into "users are frustrated" sends a team to build the wrong thing. Mine reported counts, never adjectives. Anything under five items is marked directional, quotes are verbatim, and anything it can't classify goes to a person.

  4. Switch things off.

    An end-of-day brief cost hours of compute on the most expensive model for a summary nobody needed at 17:30. I deleted it, kept the morning one, moved it to a cheaper model and capped it at one call per source. Scheduled agents fail on cost before they fail on quality. And a model that's validated isn't the same as one that's switched on: I paused one because the data underneath it was being replaced.

  5. Shadow before drive.

    In a side project that decides which messages need my attention, the model runs alongside simple rules first. Users' real actions are the ground truth, and the model only takes over once it beats the rules on the same events. If it errors, the rules take over. It never silently hides anything.

  6. Know where your knowledge ends.

    I've evaluated open-weight models for cost and data residency and haven't run one in production, and I'll say so. What I do know deeply is subscription and marketplace economics, and that's what decides whether a tool measures the right thing. "Feature-level MRR" doesn't exist in a subscription business, however confidently a model computes it.

This site's build fails if a claim I've retired, an internal number or a client name reaches the page. AI writing drifts toward the plausible, so I don't rely on catching it by eye.

Thinking about

Most companies now have dozens of people asking AI the same questions, each starting from scratch: what does this metric mean, who owns this, why did we decide that. I'm exploring what a shared "second brain" for a company would look like. It would be a small, curated layer that tells any AI assistant what's true about the business today, what was decided and why, and which sources to trust over others, with live tools fetching the details on demand. The interesting problems aren't technical. They're keeping it current without anyone writing a wiki, separating a brainstorm from a decision, and deciding what never goes in. Early thinking, nothing built yet.