AI Build Bytes
For developers building with LLMs

AI engineering, one byte at a time.

Short, interactive lessons called bytes that teach you to build AI features that hold up in production: retries, caching, structured output, agents and guardrails.

Byte 01 is free to read now. The interactive Track 1 opens soon. Get Byte 01 free

Inside every byte

Watch2 min
Build4 min
Check1 min
failure lab · simulationidle

Scenario: an AI agent issues a refund through a payments API that supports idempotency keys.

Inject failures
    API calls
    –
    Elapsed
    –
    Duplicate refunds
    –

    What's a byte?

    Seven minutes. One pattern. Practised.

    Every byte has the same shape, so you always know what you're getting and where you are.

    1. WatchA two-minute visual explainer of one production pattern. No filler, no intro music.
      2:00
    2. BuildWrite the code yourself, against real failure cases like timeouts, 429s and malformed output.
      4:00
    3. CheckAutomatic checks tell you what broke and why. Pass, and the pattern is yours.
      1:00

    Byte 01, line by line

    Most retry code makes outages worse.

      Before

      The loop most of us write

      It works in the demo. In production it retries instantly, forever, on errors that will never succeed.

      Step 1 of 5

      Retry only what's transient

      429s, 5xx errors and timeouts can succeed on a second try. A 400 or 401 never will, so fail fast and say why.

      Step 2 of 5

      Cap the attempts

      Four tries, then surface the error. An outage shouldn't hang your app or your user.

      Step 3 of 5

      Back off, with jitter

      Wait 1s, then 2s, then 4s, and randomise each wait so a thousand clients don't all retry in the same instant.

      Step 4 of 5

      Honour Retry-After

      When the API tells you when to come back, listen. It knows its own load better than you do.

      Step 5 of 5

      One retry layer only

      Your SDK already retries. Turn that off, or drop your loop. Stacked layers quietly turn one request into twelve.

      Scroll, tap a step, or use the buttons.

      Byte 02 preview

      Is prompt caching worth it for you?

      Most apps resend the same system prompt and documents on every call. Move the sliders to match your app.

      System prompt, instructions and documents that repeat on every call.
      The user's message and anything else that changes.
      Check your provider's pricing. Cached reads are commonly 50–90% cheaper.

      You'd spend less on input tokens

      –

      saved every month

      Without caching–
      With caching–

      Simplified: input tokens only, assumes every request hits the cache, ignores cache-write costs and output tokens. Byte 02 covers how to structure prompts so the cache actually hits.

      Start where you are

      Find a suggested starting point.

      Three quick questions, each about one topic. Track 1 below then highlights where to focus. It's a pointer, not a test.

      1. Placement checkA few questions like these.
      2. Your pathFocus where your answers show a gap.
      3. Checked buildsEvery byte ends with code that's tested against real failure cases.
      Question 1 of 3

      Track 1 · 6 bytes · about 42 minutes

      Ship your first reliable AI feature.

      Six bytes, from basic to advanced. Each one ends with something you build and get checked.

      1. 017 min

        Retries that don't make outages worse Free

        You'll build a retry wrapper that survives 429s and 529s.

        Field noteRetry storms that turn a small outage into a big one.
        Start hereFocusStrongBasic
      2. 027 min

        Prompt caching to cut cost and latency

        You'll restructure a prompt so repeat calls cost less and return faster.

        Field noteThe same 4,000-token system prompt, paid for on every call.
        Start hereFocusStrongBasic
      3. 037 min

        Validate LLM output and recover from failures

        You'll add schema validation and automatic repair to structured output.

        Field noteOne malformed response that stops a whole batch job.
        Start hereFocusStrongIntermediate
      4. 047 min

        Why your agent loops forever

        You'll give an agent step budgets, loop detection and a safe exit.

        Field noteAn agent calling the same tool until the budget runs out.
        Start hereFocusStrongIntermediate
      5. 057 min

        Idempotency: retry without double-charging

        You'll prevent duplicate actions when a side-effecting call is retried.

        Field noteFrom payments, where a duplicate retry is a duplicate charge.
        Start hereFocusStrongAdvanced
      6. 067 min

        Guardrails every AI feature needs

        You'll wrap one feature in input checks, timeouts and fallbacks.

        Field noteThe input nobody tested, in front of a real customer.
        Start hereFocusStrongAdvanced

      From production, not from tutorials

      Every byte starts as a real problem at work.

      The patterns come from systems where failure costs money. Then they're cut down to seven minutes, so you get the lesson without the incident.

      Grounded in real failures

      Each byte is built around a failure mode that shows up in real systems, explained by someone who has debugged them.

      Written by an industry expert

      18+ years building payment systems: reconciliation, settlement, ledgers and idempotency, where a retry that runs twice charges someone twice.

      Guest bytes from practitioners

      Senior engineers sharing the patterns they rely on day to day, starting with Track 2.

      Coming in Track 2

      Where this goes

      Start with reliability. Grow into agents.

      Each track builds on the last, so the bytes compound.

      Now · Track 1

      Ship reliable AI features

      Retries, caching, structured output, agent loops, idempotency and guardrails.

      • 6 bytes
      • Byte 01 free
      Later · Track 3

      Engineer like a senior

      Design reviews, failure modes and the trade-offs nobody writes down.

      • Planned
      Get Byte 01 freeSubscribers help decide what goes into Track 2.

      Questions

      What exactly is a byte?

      About seven minutes: a two-minute visual explainer, four minutes building the pattern yourself, and one minute of automatic checks.

      Is it a video course?

      Partly. Each byte opens with a short explainer, but most of the time you're writing code that gets checked, not watching.

      Who is it for?

      Developers who can already code and want to build AI features properly, from early-career to senior.

      Which languages?

      Python examples first, with more to follow.

      What does it cost?

      Byte 01 is free, no card needed. The full Track 1 is a one-off A$29, or A$19 for our first 100 founding members. No subscription: pay once, keep it.

      When does it launch?

      Byte 01 is available now when you sign up. You'll get one email when the rest of Track 1 opens.

      Your first byte is free

      Get the Byte 01 pattern and code now, free. The interactive version and the other five bytes open soon: one payment of A$29 for all of Track 1, or A$19 for our first 100 founding members. No subscription.

      No card needed. Privacy · Unsubscribe any time.