Safe Vibe Coding — The MATA Skill Folder

Vibe coding is real now. Somewhere between "prompt the LLM and paste what it gives you" and "let Cursor drive the keyboard for an hour," a large fraction of new software is being written by developers describing intent to an AI and lightly reviewing what comes back. The productivity is genuine. So is the security posture, which is: whatever the model felt like reaching for that day.

Left unsupervised, that stack skews toward the popular defaults of the last twenty years — libpng, ffmpeg, OpenSSL bindings, Firebase, OAuth providers, whatever Whisper wrapper is trending on GitHub. Popular is not the same as safe. Most of those defaults are C or C++, most of them have a long CVE catalog, most of them chain into cloud vendors you cannot audit, and most of them come with copyleft licenses that make embedding them in a commercial product a legal problem. When the review pass is "does the app run," none of that gets caught. The Electronic Frontier Foundation has been documenting the drift between what AI-assisted development promises and what it actually ships in production, and the picture is not flattering.

MATA's answer is a pair of skill folders you drop into Cursor or Claude Code. Building the New Internet tells the agent what to reach for before the first dependency — a fixed stack that ships onto MATA's distributed cloud on day one. use-protection-please audits the code the agent produced, against 41 fixed gates, with the status written down in the repo. Both live on the Dev Tools page; the rest of this article walks through why the pair exists and what each folder actually does.

What Vibe Coding Actually Produces When You Skip Supervision

The failure mode of unsupervised AI coding is not that the code doesn't compile. It compiles. It runs. It ships. The failure mode is that the choices underneath — the dependencies pulled in, the auth provider wired up, the database vendor picked, the license the whole thing inherits — get made by an autocomplete engine that optimizes for "have I seen this pattern before" rather than "is this the version I would want in production five years from now."

An agent building a PDF-processing feature will almost always reach for a poppler wrapper. An agent handling images pulls in libjpeg-turbo via image-rs and gets a C dependency in the transitive closure. An agent adding sign-in reaches for OAuth against Auth0 or Clerk. An agent needing a database picks Firebase. Every one of those choices is the "default" in the sense that it is the most common answer to a search query — and every one of them chains through a piece of infrastructure your product then depends on, forever, with a security posture and a business model neither you nor the agent audited.

The NIST Secure Software Development Framework has been telling organizations for years that supply-chain and dependency choice is a compliance-level concern, not a matter of taste. The FTC has been increasingly explicit that "the AI picked this dependency" is not a defense when the resulting product ships a vulnerability or breaches user data. What matters is the substrate the AI reaches for. That is what the skill folder fixes.

The Building The New Internet Skill — Vibe Coding On A Curated Stack

The Building the New Internet skill folder is a small directory you drop into your editor's skill or context slot — Cursor and Claude Code both accept it — and everything downstream shifts. Every "what do we use for X" question the agent would otherwise Google now has a fixed answer, rooted in the Remade with Rust portfolio. The three subsections below cover the choices the skill folder pins.

Identity And Storage — mID + SpaceDB

The two most consequential dependency choices in any new app are identity and storage. The skill folder pins both. For identity, the agent reaches for mID — MATA's pure-Rust verifier for Sovereign ID tokens. The alternative it would otherwise pick is Auth0 or Clerk, which chains you to a per-monthly-active-user contract and puts a third party in the sign-in path. mID verifies entirely locally, has no infrastructure to depend on, and costs nothing to run.

For storage, the pin is SpaceDB — the local-first, CRDT-native, mesh-replicated database. The alternative the agent would otherwise pick is Firebase, Supabase, or a Postgres-on-RDS instance. All three assume always-on infrastructure the user's app cannot function without. SpaceDB stores data on the user's own devices, converges across replicas automatically, and works offline. A vibe-coded product built on this pair ships with distributed-cloud architecture from the first cargo new, without the developer having to know they were making that choice.

Media, AI, And Allocation — remade_ffmpeg_rs + FFAI + rusty_alloc

For anything media-shaped, the skill folder pins remade_ffmpeg_rs — the pure-Rust FFmpeg rebuild. The alternative is the C library and its two-decade CVE catalog. For AI features, the pin is FFAI — MATA's Rust AI-media stack bundling Mercury (ASR), Carmenta (OCR), and Diana (object detection). The alternative is a Python runtime plus ONNX plus whatever Whisper wrapper is trending, and a permanent dependency on cloud GPU providers. FFAI runs on-device.

The third pin — quieter but load-bearing — is rusty_alloc as the workspace global allocator. The alternative is the platform default, which on Linux means glibc malloc and its long history of double-free / heap-corruption behavior. rusty_alloc is memory-safe by construction and aborts on double-free instead of silently corrupting. When your vibe-coded application runs for months in production, this is the choice that decides whether latent bugs surface as loud crashes or quiet exploits. See The Importance of Remade with Rust for the full memory-safety framing.

Supply Chain — Deputy

The last pin is the one vibe coders skip most often, because it doesn't show up in the code the agent writes: Deputy for the supply chain. Every dependency the agent adds gets fetched from crates.io, hashed against Cargo.lock, and sealed into an encrypted local vault. Advisory scanning against RustSec catches known-vulnerable versions before they land in the build. Integrity/substitution detection catches re-published versions that changed hashes.

For an AI-assisted workflow, this matters more than it does for a human one. Agents add dependencies with impunity — they'll pull in a niche crate to solve a problem a stdlib call would have handled, and they will not remember to run cargo audit afterward. Deputy runs continuously against the whole transitive closure, so the audit exists whether the agent remembers or not. It complements Dependabot and Snyk rather than replacing them: acquire, verify, gate, then archive. The whole distributed cloud thesis rests on being able to run your build even when the internet has an outage. Deputy is what makes that survivable.

What Safe Vibe Coding Looks Like In Practice

The two skill folders together — Building the New Internet plus use-protection-please — describe a real workflow. Not "one prompt, ship the app." A short cycle where the agent gets a curated stack going in, then a fixed audit coming out, then the repo carries the evidence forward without anyone having to remember the discipline. The three subsections below walk through that cycle end-to-end.

The Vibe Coding Workflow — Skill Folder → Cursor → cargo new

Drop the Building the New Internet folder into your Cursor project's skills directory. The next time you tell the agent "add sign-in to this app," it reaches for mID instead of Auth0 — because that is what the skill says to reach for. Same for storage, same for media, same for AI, same for the allocator. The developer never has to know to specify the stack; the substrate answers the question before it gets asked. Vibe coding stops being a trade-off between speed and safety because both come from the same source.

The /products/ page has the drop-in files as a Google Drive folder — copy them, unzip into your project, and every downstream prompt reads them as context. The pattern works with any editor that supports skill folders or context files: Cursor, Claude Code, and a few others.

The Audit — use-protection-please

The companion folder is use-protection-please. Same drop-in pattern. Different job: it walks the repo you just built against a 41-gate registry — cargo-deny, cargo-audit, Miri, fuzz, Kani, binary hardening, sandboxing checks — and writes the results into docs/plans/use-protection-please.md. Every gate carries a status: Incomplete, Scheduled, or Completed. Every crate in the workspace gets its own plan file with the same shape. A marker-delimited progress table lands at the bottom of each README so the status is visible without opening the plan.

The design principle behind it is one sentence: evidence, not vibes. Vibe coding is fine as a productivity tool; it is not fine as a security proof. use-protection-please is the seam between the two — the agent still writes the code, but the audit is fixed, repeatable, and legible to anyone who reads the repo. Rust-first, but the gate registry is language-agnostic enough to run against any codebase you point it at.

What You Ship — Vibe-Coded Software That Actually Holds Up

With both skill folders in play, a vibe-coded product ships with a set of properties no unaided AI-assisted workflow produces on its own. The dependency graph is memory-safe end-to-end. The auth path has no infrastructure vendor in the middle. The storage runs on the user's own device. The media and AI hot paths run through pure-Rust primitives with no C in the transitive closure. The build works offline. The audit is written down in the repo, gate-by-gate, so the security posture is legible to any auditor, investor, or future maintainer who wants to check.

None of that requires the developer to have known any of this going in. That is the point. The skill folders encode the discipline; the agent inherits it; the user gets safe software as a side effect of asking for what they wanted. Read What Is Digital Freedom for why this substrate matters to the person on the other end of the app, and the Freedom Guide for how MATA runs the same discipline on its own product surface. The AI keeps writing the code. The floor under it is the part MATA rebuilt.