Bas Pijls

Bouwer
or
Bauer

Software with agents, for and in education.

Softwareedition one: laid by hand

Every brick laid by hand. You know each one, because you put it there.

Building by hand

Fab Academy, Waag Amsterdam, 2022. Twenty weeks, eighteen assignments.
The last year before AI.

2022 to 2026

Post-FabAcademy

I kept making things, and step by step I let AI write more of them. Every step felt a bit like cheating.

I do itthe AI does it  in the loop of write, apply, run, fix

  1. 2022

    Fab Academy ends. The last thing I built entirely by hand.

  2. Nov 2022

    ChatGPT

    I copy code out of a chat window and paste the errors back in. It felt like cheating.

  3. 2023

    The HBO-ICT knowledgebase for students. Hundreds of commits, until 2025.

  4. Copilot in VS Code

    Autocomplete. Tab, tab, tab: it writes the next line, I write the rest.

  5. 2024

    tURLte on the web. A crowd controller: firmware, enclosure and a Python client.

  6. Cursor

    I clicked Accept all changes and eventually stopped reading all the code. I felt a little ashamed, like I'm not doing my job properly.

  7. 2025

    Hexagonal automata. An egg that is an iBeacon. A web MIDI sequencer. Spritecast. The ICT Fusion knowledgebase.

  8. March 2026

    vonk and paws

    An ASUS Ascent GX10 for local models and a PC just for the agents. I learn security, infrastructure, version control. With Claude Code, the loop I was ashamed of runs by itself.

  9. The ASUS Ascent GX10: a small dark box with a ribbed front

    vonk

    ASUS Ascent GX10

    • NVIDIA GB10 Grace Blackwell
    • 20-core Arm CPU
    • 128 GB unified memory
    • 1 TB SSD, up to 1 petaFLOP (FP4)

    Runs every model: chat, code, images, speech, embeddings.

    The ACEMAGIC K1: a small black mini PC

    paws

    ACEMAGIC K1 mini PC

    • AMD Ryzen 5 7430U
    • 6 cores, 12 threads
    • 32 GB DDR4
    • 512 GB SSD

    The agents' PC: builds, tests and hosts.

    Photos: ASUS, ACEMAGIC

  10. No token limits or bills.

    With my own hardware I could play with AI all day without counting tokens or watching a bill grow.

    - The only way to learn is to play.
    - The only way to play is when nothing is at stake.

    So I played. That is how Game Babies happened.

Game Babies

The first thing I made on the new machines. Old arcade games crossed into new ones: one agent builds the offspring, another playtests it, a third keeps improving it. I only choose which ones to keep.

The arcade and its source

I didn't build those games.
I bred them.

It stopped feeling like building. It started to feel like farming: choose the seed, look at what comes up, keep the good ones, compost the rest.

The seed

Give me one word. A graph grows from it, and from the graph a report with pictures. No search, no internet, no sources: everything comes out of the models on my own machine. What else can a model give you on its own?

knowledge-farm.feib.nl

Plant a word with the audience. Grow a report in Dutch, as a flyer, as a poem.

Also on my own network, where the images are faster. Source code.

Playing around

So I played. Useless things, cheap to fail, to find out what the models can do on their own and where they lie.

The harvest so far

Eight months, mostly next to teaching. I wrote almost none of this code. Can I be proud of it?

projects
77
prompts typed
2,082
commits
~2,200
/plan used
104
Prompts per month, 2026

    Tending

    What I actually typed. Almost never "write this function". Mostly deciding, checking, integrating and running.

    1,731 prompts, by kind of work
      • I predict it is still buggy.distrust
      • I still find no evidence the wikipedia grounding actually works.ask for proof
      • Close the loop: check the generated mermaid code just by running it.build feedback loops
      • The interface is entirely too verbose.taste, said ten times
      • No student data should be sent to Claude.ethics can't be delegated

      The kitchen garden

      Grow exactly what your own lesson needs, in a day, instead of bending the lesson to the tool that exists. No accounts, no student data stored, one link.

      No backend, no database, no server to keep alive

      The link is the database

      An exercise, a class list or a diagram is packed into the part of the URL after #, which browsers never send to a server. Share it as a link or a QR code; whoever opens it has everything.

      1. JSON
      2. deflate
      3. base64url
      4. #fragment
      // design-system/…/codec.js (shortened)
      export async function encode(payload) {
       const json = JSON.stringify(payload);
       const packed = await pipe(json,
       new CompressionStream('deflate-raw'));
       return toBase64Url(packed);
      }
      // a Flowslate exercise for students:
      // flowslate.ict-hva.nl/#p=7VjbbtswDP0V…

      Git is the storage service

      Students keep their notes and websites in their own GitLab project. The browser talks to the GitLab API directly with the student's project token; a save is a commit, publishing is GitLab Pages. The token can be locked with a passphrase and never leaves the browser.

      1. browser
      2. PRIVATE-TOKEN
      3. GitLab API
      4. commit
      // noted/src/sync/gitlab.js (shortened)
      await fetch(`${url}/api/v4/projects/${project}`
       + '/repository/commits', {
       method: 'POST',
       headers: { 'PRIVATE-TOKEN': token },
       body: JSON.stringify({ branch,
       commit_message: `Noted backup ${now}`,
       actions }), // every note as .md
      });

      Weeding

      AI for running education. When software is cheap it is tempting to build a system that rules a messy organisation. Fast iteration only helps if you aim at simplicity. And student data only ever goes to models we host ourselves.

      curriculum-builder: 399 prompts, my biggest crop and my best weed

      Planted, never properly tended

      Code labs and experiments: overly verbose, not yet well tended, some not usable at all.

      The greenhouse

      One machine in a cupboard. Every project starts from the same template, talks to the same local models, and is checked by the same runners.

      Browser to Caddy to project stacks, which call vonk, the local model gateway; CI runners and a shared browser sit beside them. browser Caddy*.paws.home project stacksfrom _templateFastAPI, React, Postgres, jobs vonklocal modelstext, code, image, speech CI runners and a shared browser

      The whole farm

      Four machines on one private network. A home server builds, tests and hosts. A GPU box serves every model. A cloud VM and a VM at school put the public apps online, and docker-manager keeps an eye on all four.

      Map of the setup in System Composer: my laptop and phone reach the home server over a private network; the home server runs Caddy, the project stacks, CI runners, a shared browser and docker-manager; the GPU box runs LiteLLM in front of text, image, speech and embedding models; a cloud VM and a VM at the HvA serve public apps through Caddy; students reach them, and GitLab Pages, over the internet.
      An agent took the inventory, read-only. I drew it in System Composer. Roles only: addresses, ports and the list of things to fix stay off the slide.

      Everyone can grow software

      Not only developers, and not only for school. Soon everyone has a patch: things I wanted for myself, grown in my own time.

      Enabling others to take the leap

      Most people stop at the first wall: hosting, identity, data, privacy. These are the bridges, small enough to build ourselves.

      What we teach now

      Our curriculum already names most of this, but as a side subject: an AI article in some profiles, a criterion at the bottom of the list. Farming makes it the main work.

      1. Specify and verify. A story before the code, evidence after it: tests, CI, using it like a user. And enough bricks to check the wall.
      2. Tend, over time. Read what the agent did, refactor before it grows, prune, replant. Assess the grow log, not only the harvest.
      3. Product judgement. Simpler, fewer words, one link. Saying no to a feature is a skill.
      4. Responsibility. Which data may go to which model, which keys an agent holds, and when a human decides.

      Our students won't lay bricks.
      They'll run farms. Let's teach farming.

      Grow logs

      6 projects: from the first prompt to today:
      - what I asked for,
      - how it grew,
      - what I did to keep it good.

      1. curriculum builder Roadmap editor, wiki service and renderer. Six months, three repositories. 430 requests · 278 commits · 40 days
      2. Game Babies Agents breed arcade games and improve them forever. Clean-room rebuild months later. 94 requests · 34 commits · 11 days
      3. my-vault My own notes app, used daily. Every annoyance became a feature. 80 requests · 64 commits · 13 days
      4. this talk This website: five days from "which angle?" to 45 films. 39 requests · 18 commits · 5 days
      5. noted Note-taking for students, no backend. 36 requests · 38 commits · 10 days
      6. Algebra Cleanup A tile game that grew into an algebra system, 30 requests · 48 commits · 7 days