VibeFlow-P5

A browser visualisation of 150 particles drifting under Perlin noise and pushed around by the mouse, served by a Go file server and shipped as a Docker image. The repository is small enough to read in a few minutes. What makes it worth keeping is the README — a manifesto for vibe coding written about eight weeks after the term was coined — and the Dockerfile, which is considerably more serious than the application it contains.

Who built itA DevOps engineer, going by his repositories: Terraform modules for AWS IAM roles, WAF and CloudWatch alarms, Go command-line tools for reading Terraform plans, and a study repository for the CKAD Kubernetes exam. Of his 120 public repositories 106 are forks of other people’s work; of the fourteen that are his own, this is the only one that is not infrastructure tooling.

1. 01

   A period document, written eight weeks into the term

   The README is not documentation; it is a declaration, headed “Vibe Coding Manifesto”, and it opens by attributing the approach to Andrej Karpathy in February 2025. That date holds up: Karpathy coined the phrase in February 2025, and Collins made “vibe coding” its Word of the Year for 2025 on the strength of a large rise in usage from that first appearance. The repository’s first commit is dated 29 March 2025, so the manifesto was written roughly eight weeks after the word existed — early enough to be a source rather than a summary of one. It sets out four claims in its own words: natural language instead of hours of typing, aesthetics before syntax, minutes instead of days, and development without “the traditional gatekeeping of specialized technical knowledge”.

2. 02

   The epigraph the author labels as invented

   The closing lines are the most unusual thing in the repository. The first is “Vibe Coding is not the future of programming; it’s the present of creative expression through code” — and it is signed, in the README itself, as “a hypothetical quote from 2025”. A project that cites a quotation and simultaneously marks it as made up is doing something a manifesto usually avoids. A second epigraph quotes “Programming is not about typing, it’s about thinking” and then qualifies it, adding that sometimes it is also about pausing to enjoy the aesthetic dimension of the digital world.

3. 03

   What the code is

   The whole application is one file of 3,332 bytes. It creates 150 particles, gives each one a velocity and no acceleration of its own, and then every frame steers them with Perlin noise sampled at their own coordinates; within 200 pixels of the cursor they are attracted or repelled according to the cursor’s vertical position, and the hue of everything on screen comes from its horizontal position. Particles are drawn as circles in additive blend mode over a background redrawn at 0.05 alpha each frame, which is what produces the trails. One detail reads as unedited machine output: particles added by the mouse are removed in two unrelated places — the mouse handler drops the oldest with `shift()` once the population passes 150% of the target, and a `setInterval` running once a second filters out the ones whose lifespan has run out. Neither path knows about the other, and the 150 particles created at startup never expire at all.

4. 04

   The Dockerfile is more serious than the application

   The last commit, a fortnight after the first, is titled “Optimize Dockerfile for security, performance, and cross-platform support”, and it does what it says for a container whose payload is a 3 KB particle demo. It builds in `golang:1.20-alpine` with `--platform=$BUILDPLATFORM`, then runs from `scratch` — no shell, no package manager, nothing to find a foothold in — as UID 10000 rather than root, with `CGO_ENABLED=0` for a static binary, `-trimpath -ldflags="-w -s"`, cross-compilation driven by `TARGETOS` and `TARGETARCH`, and a `sha256sum` of the built binary recorded alongside it. The repository contains no `go.mod`, so the build creates one inside the image. The file also keeps a comment block offering two mutually exclusive ways to handle dependencies — create the module during the build, or copy an existing one — with instructions to comment out whichever does not apply. That is a recognisable shape of assistant-written configuration: unable to know which case holds, it ships both and leaves the choice.

5. 05

   The German is still in the comments

   Both the Go server and the Dockerfile carry comments in German: “Statische Dateien im Verzeichnis "static" bereitstellen”, “Server auf Port 8080 starten”, “Binärdatei aus dem Builder-Stage kopieren”. Nothing in the repository is otherwise in German — the README, the HTML and the sketch are all in English. The comments are the residue of the conversation that produced the code, and they record that the person asking was writing in German and the model was answering in kind. The README’s account of the process, that it happened “in a single conversation” with Claude, is otherwise unverifiable; the comments are the one part of that claim the repository corroborates.

6. 06

   What the numbers look like

   Four commits across sixteen days, from 29 March to 13 April 2025, and nothing since. One author, no releases, no tags, no issues and no pull requests. One star and no forks. Seven files, eight kilobytes, MIT licensed, with topics including `vibe-coding`, `ai-generated` and `language-model-programming`. The README’s claim that the code was produced with no manual debugging is the author’s own and cannot be checked from the repository; what can be checked is that the code runs the way the README says it does, because the sketch, the server and the container are all small enough to read in full. There is no third-party coverage of this project of any kind — no press, no Hacker News thread, no discussion.