How I Made a Voice Clone in Minutes, Using Google Antigravity, Gemini 3.8 Flash TTS and My Harness

Leveraging my Harness: Spec-Driven Development, TDD, and Self-Correcting Loops in Action

Howdy friends! Have you ever wanted to clone your own voice so you can generate expressive narration for presentations and demos, create audio versions of your blogs, or even co-host multi-speaker AI podcasts? Or maybe you just fancy having deep-fake phone calls with family members!

I certainly have! Honestly, I don't love recording voiceovers — mostly because fluffing a line and having to go back and correct your mistakes is a pain.

In this post, I'll show you how I used Google Antigravity and my reusable agent harness to build voice-replication — an open-source Python application that clones your voice and generates expressive single- and multi-speaker speech with Gemini 3.8 Flash TTS. And if you want to clone your own voice (or script multi-speaker dialogues) without writing any code yourself, you can simply clone the repo, record two short WAV clips, and run the steps we'll walk through below!

Google first introduced custom voices and voice cloning in its "Chirp 3" Text-to-Speech (TTS) model back in 2025 — but it wasn't accessible to most of us, as it required getting onto a dedicated enterprise allowlist. Then, in September 2026, Google brought Voice Replication and Voice Design to the masses with Gemini 3.8 Flash TTS (gemini-3.8-flash-tts). Now anyone can clone their own voice, create custom vocal personas from a prompt, and add rich style guidance and inline vocal expressions like whispering, laughing, sighing, and pausing.

Today I decided to give this a try. And because I've been doing quite a few blogs and talks about Harness Engineering lately, I decided to put this into practice. So, the goal today was to build a clean voice cloning application from scratch, using Google Antigravity, and leveraging my existing coding harness. The application will:

• Quickly and easily clone a supplied voice, handling audio normalisation and mandatory consent checks
• Persist and manage my voice clones in Google Cloud
• Provide a simple interface for generating expressive monologue and multi-speaker dialogue from text in my voice

So, grab your coffee and your cat and let's see how to go from nothing to a fully tested, documented and public-repo-ready application in one hour!

Why Build a Whole Application Around a Couple of API Calls?

At first glance, calling the Gemini API's /v1beta/voices endpoint is pretty simple. You send two audio clips to client.voices.create() — a reference recording of your voice and a recording of you reciting a mandatory consent statement — and you get back a voice identifier (voice_...) that you can pass to client.interactions.create() using gemini-3.8-flash-tts.

"Wait — if it's that simple, why build a whole CLI and storage layer around it?"
"Partly for convenience... and mostly to give my agent harness a proper workout!"

Let's be honest: if you only want a one-off voice clone, a 20-line Python script is probably enough. (Interestingly, although the docs mention an interactive Voice Replication experience in Google AI Studio, that option wasn't actually showing up in the AI Studio UI for me in the UK.) My main motivation for building a full CLI around all this was to test how quickly my Google Antigravity harness could turn a loose idea into a well-engineered, tested tool.

That said, wrapping the raw API in a proper CLI also solves a few everyday annoyances:

• Automatic audio conversion: For best results, Google recommends 24kHz, mono, 16-bit PCM WAV audio and a 10 to 30 second reference clip. Meanwhile, your phone or desktop recorder probably spits out 48kHz stereo .m4a or .mp3 files. Having the CLI automatically convert and check your clips via ffmpeg saves manual conversion steps.
• Consent sanity checking: To prevent unauthorised voice cloning, you must record a verbatim consent phrase ("I am the owner of this voice and I consent to Google using this voice to create a synthetic voice model."). Sure, if you upload the wrong file or fluff a word, the Voices endpoint will just reject it — hardly the end of the world! — but checking it first with gemini-3.5-transcribe tells you exactly which words didn't match, and gave us another fun Gemini API integration to play with.
• Voice persistence and TTL expiry: When you create a stateful voice (store=True), it is scoped to the Google Cloud project tied to your GEMINI_API_KEY with a 1-year retention TTL (or 7 days if you use a stateless voicekey_... token with store=False). Keeping your voices on Google Cloud Storage alongside your master WAV clips means refreshing an expired voice a year from now (or using it from another machine) won't be a PITA.
• Expressive multi-speaker scripting: Gemini 3.8 Flash TTS supports turn-level style instructions (speech_metadata.style — e.g. "whispering" or "excited") and inline vocal tags like <laugh>, <sigh>, and <short pause>. Typing raw JSON payloads by hand gets old fast; feeding a clean Markdown monologue or YAML dialogue script into a CLI is much nicer.

Best of all, because the entire workflow is wrapped behind simple make targets (including make design if you also want to generate brand-new synthetic voices from a text prompt), you can clone derailed-dash/voice-replication and use it out of the box without touching a line of Python.

Starting with a Reusable Harness: GEMINI.md, Skills, MCPs, and Plugins

Before I even typed my first prompt, Antigravity already knew how I build software. Why? Because of my reusable ~/.gemini harness.

As I covered in From Vibing Chaos to Reliable Agents: The What, Why, and How of Harness Engineering, separating Context (HOW) from Specification (WHAT) is the foundation for getting consistent, production-grade output from an AI coding agent. Instead of repeating my coding standards in every prompt, my global harness combines a GEMINI.md engineering constitution with plugins, skills, and MCP servers across every repository I open:

• Modern Python & uv: Enforces Python 3.13, uv environment management, and modern type hinting.
• Latest GA Gemini Models via the Interactions API: Mandates current models and never falls back to legacy generateContent endpoints.
• Plugins, On-Demand Skills, & Live MCP Servers: Pairs bundled plugins (gemini-api, google-cloud-developer) and live documentation MCPs (gemini-api-docs, developer-knowledge) with curated skills.
• Self-Documenting Makefile & .env.template Hygiene: Every repo gets a Makefile, a sanitised .env.template, and rules to ensure nothing sensitive ever gets pushed to GitHub.
• Spec-Driven Development, TDD, & Self-Correcting Loops: Every non-trivial feature starts with SPEC.md, TODO.md, and LOOPS.md, ensuring our harness verifies each iteration both deterministically and semantically.

Interactive Discovery: Using /grill-me Before Writing a Line of Code

I kicked off the session with a single prompt using the /grill-me slash command:

/grill-me I want to build a project for managing my personal voice replication,
using gemini flash tts, and the guidance here:
https://aistudio.google.com/docs/voice-replication.
I want to persist my voice clone in my GCP project.
We will use Python. I can provide audio clips, and the mandatory recorded statement.

Instead of immediately hallucinating half-baked Python files, Antigravity followed my harness protocol:

1. Activated Relevant Skills: It read gemini-api-dev, google-cloud-storage-bucket-architect, google-cloud-storage-basics, and retrieving-developer-knowledge.
2. Queried Live Upstream Docs via MCP: It pulled the current documentation for Voice Replication, Speech Generation, Voice Design, and Audio Transcription from the Gemini API Docs MCP server, and checked Cloud Storage Classes, Autoclass, and Pricing via the Developer Knowledge MCP server.
3. Conducted a Structured Design Interview: Using multiple-choice questions, it interviewed me across several architectural trade-offs to lock in concrete design decisions.

The resulting solution — fully generated by Gemini Argon inside Antigravity — looks like this:

Locking the Blueprint: SPEC.md, TODO.md, and LOOPS.md

Once the /grill-me interview wrapped up, Antigravity activated my spec-driven-development, planning-and-task-breakdown, agent-aware-cli, and loopy skills to generate the project's specification artefacts on disk before writing any code:

• SPEC.md: Captured the system architecture, Gemini 3.8 TTS & Gemini 3.5 Transcribe API contracts, the ffmpeg 24kHz mono WAV pipeline, the hybrid GCS Coldline/Standard persistence design, the CLI command table, explicit operational boundaries (Always Do / Ask First / Never Do), and the complete two-tier verification rubric.
• tasks/plan.md & TODO.md: Decomposed the build into eight independently testable vertical slices with clear verification commands and phase checkpoints.
• LOOPS.md: Saved the self-correcting TDD Vertical Slice Loop prompt and its binary acceptance rubric, so the loop can be re-run at any time.

As I wrote in Spec-Driven Development For-the-Win: Disposable Code, Living Blueprints, and Building Like a Boss, code is disposable; the specification is what matters. Pausing at a hard-stop approval gate to review SPEC.md and LOOPS.md took two minutes — and meant that when I typed y to start building, the agent had zero ambiguity left to guess about.

Executing with Loopy + TDD: Red, Green, Refactor

With the spec approved, Antigravity activated loopy and test-driven-development and executed each vertical slice in TODO.md following our loop cycle: Observe -> Choose -> Act -> Verify -> Record.

If you read Loop Engineering in the Harness: Autonomous, Self-Correcting Systems, you will recognise the mechanics immediately:

• Red Phase First: For every slice, Antigravity wrote the failing pytest test file in tests/ first and ran uv run pytest to prove it failed for the right reason.
• Iteration Discipline (The One-Change Rule): Each pass implemented a single semantic slice (or fixed one behavioural bug) before re-verifying. If a check failed, the agent knew exactly which change caused the issue — whereas purely mechanical linting or formatting fixes could be batched together.
• Fast, Offline Testing: Audio tests run against real ffmpeg using tiny generated test clips, while Gemini API and Cloud Storage calls use injected fakes — so the entire 38-test suite runs offline in about 3 seconds and with 0 API cost.

Two-Tier Verification: Mechanical Short-Circuiting + Stateless Semantic Critic

Left to its own devices, an agent will happily write some questionable code, quietly violate your architectural rules, and declare victory. Why? Because the same agent that wrote the code is grading its own homework inside a polluted context window.

To fix this — and avoid burning tokens on AI code reviews when basic tests or linters are still failing — my harness checks the work in two stages:

1. Run the fast, free, deterministic tests first.
2. Only bring in a separate "Critic" agent once the basics pass.

Tier 1: The Deterministic Mechanical Gate (make check, $0 Cost)

After every slice, Antigravity runs make check, which executes four deterministic tools in sequence:

uv run codespell -s          # catch spelling mistakes in code and docs
uv run ruff check --fix .    # lint and auto-fix formatting issues
uv run pyright               # static type checking
uv run pytest -m "not live"  # run fast offline unit tests (skip live cloud calls in the inner loop)

If any Tier 1 check fails — a single typo caught by codespell, an unused import in ruff, a type mismatch in pyright, or tests failing — the loop short-circuits immediately and fixes the mechanical defect before any LLM review is attempted.

Tier 2: The Stateless Semantic Critic

Once all slices pass Tier 1, the loop spawns a fresh, stateless research subagent with zero builder conversation history. That critic reads the codebase cold and grades it against the numbered binary assertions codified in SPEC.md and LOOPS.md:

Rubric ID	Dimension	Binary Assertion
B1	Modern Python 3.13 & Docstrings	Every .py file in src/ and tests/ has a top-of-module docstring and uses built-in types.
B2	Latest Gemini Models & Interactions API	Uses gemini-3.8-flash-tts and gemini-3.5-transcribe via google-genai (client.voices.* and client.interactions.create), with zero generateContent calls.
B3	Audio Pre-Flight & Duration Guard	Normalises input audio via ffmpeg to 24kHz, mono, 16-bit PCM WAV and strictly enforces the 10s to 30s reference duration window.
B4	GCS Storage-Class-Aware Persistence	Defaults the bucket to COLDLINE for WAV clips and overrides voices.json to STANDARD.
B5	Human & Agent-Friendly CLI	Outputs formatted Rich tables for humans, --json for AI agents, --dry-run for safe previews, and clear fix hints on errors.
B6	Documentation & Visual Standards	Core docs (README.md, docs/*.md, deployment/README.md) created with architecture diagram and links to official Google docs.
B7	Security & Public-Repo Hygiene	.gitignore excludes .env, data/, output/, and audio files; zero project/bucket IDs hardcoded outside .env.

When the stateless Critic finishes its audit and returns 7 / 7 PASS (100%), loopy writes the final evidence receipt to .cache/loops/last_receipt.md and prints the run summary right in chat:

Loopy — TDD Vertical Slice Loop
========================================
Stop reason : target_met (7 vertical slices completed)

Iter  Before  After   Delta   Kept  Summary
1     0/11    11/11   +11     yes   Config & Pydantic models (config.py, models.py, test_models.py)
2     11/17   17/17   +6      yes   FFmpeg 24kHz mono WAV normaliser & validator (audio.py, test_audio.py)
3     17/22   22/22   +5      yes   Consent phrase registry & gemini-3.5-transcribe gate (consent.py, test_consent.py)
4     22/28   28/28   +6      yes   Gemini Voices CRUD & TTS synthesis client (client.py, test_client.py)
5     28/32   32/32   +4      yes   Local catalogue & GCS Coldline/Standard sync (storage.py, test_storage.py)
6     32/38   38/38   +6      yes   Agent-Aware Rich/Typer CLI & examples (cli.py, test_cli.py, examples/)
7     6/7     7/7     +1      yes   Core docs, PNG architecture diagram & Tier 2 Stateless Semantic Critic audit

Well, this is pretty cool to see. Especially since I didn't write any of the rubrics or looping instructions by hand for this project. And this output appeared literally minutes after kicking off the build!

Developer Experience: A Self-Documenting Makefile and Agent-Aware CLI

Because my GEMINI.md harness pairs the agent-aware-cli skill with a self-documenting Makefile that pulls its configuration dynamically from .env.template and .env, running the application is effortless whether you are a human in a terminal or an AI agent invoking tools.

Typing make (or make help) prints every verification gate and application workflow alongside the active .env configuration:

Usage:
  make <target> [VARIABLE=value ...]

Development & Verification Gates
  install             Create/sync virtual environment and install dependencies via uv
  lint                Run deterministic static checks (codespell, ruff, pyright)
  fix                 Auto-fix formatting and lint issues via ruff and check spelling
  test                Run offline unit test suite with pytest and coverage
  check               Run full Tier 1 verification gate (codespell + ruff + pyright + pytest)

Audio Pre-Flight & Voice Lifecycle
  prep-audio          Normalise reference & consent clips to 24kHz mono WAV and verify consent
  create              Create a stateful replicated voice (store=True, 1-year TTL)
  design              Create a custom synthetic voice from a text prompt
  list / inspect      List or inspect voices in the local catalogue (data/voices.json)
  refresh / delete    Renew a voice's 1-year TTL from master WAVs or delete a voice

Speech & Dialogue Synthesis
  speak               Synthesise single-speaker audio (FILE=monologue.md)
  dialogue            Synthesise multi-speaker dialogue from YAML (SCRIPT=dialogue.yaml)

Google Cloud Storage (GCS) Backup & Recovery
  gcs-preflight       Display read-only gcloud pre-flight verification commands
  gcs-init            Provision regional GCS backup bucket
  sync-push / pull    Sync voices.json and audio WAVs with GCS

Solution Code Snippets

Let's take a quick peek under the hood at some of the code behind make create.

1. Verifying the Mandatory Consent Recording (consent.py)

The function verify_consent_audio() sends the normalised consent WAV to gemini-3.5-transcribe via the Gemini Interactions API (client.interactions.create) to verify that the spoken words match Google's mandatory consent statement before we ever call the Voices endpoint:

def verify_consent_audio(
    audio_path: Path,
    *,
    client: Any,
    language_code: str = "en-GB",
    model: str = "gemini-3.5-transcribe",
    threshold: float = DEFAULT_SIMILARITY_THRESHOLD,
) -> ConsentCheckResult:
    """Transcribe `audio_path` with `gemini-3.5-transcribe` and verify consent wording."""
    expected_phrase = get_consent_phrase(language_code)
    audio_b64 = base64.b64encode(audio_path.read_bytes()).decode("utf-8")

    bcp47_hint = "en-GB" if language_code == "en" else language_code
    interaction = client.interactions.create(
        model=model,
        input=[
            {
                "type": "audio",
                "data": audio_b64,
                "mime_type": "audio/wav",
            }
        ],
        generation_config={
            "transcription_config": {
                "language_codes": [bcp47_hint],
            }
        },
    )

    transcript = (getattr(interaction, "output_text", None) or "").strip()
    similarity = compute_phrase_similarity(expected_phrase, transcript)

    return ConsentCheckResult(
        passed=similarity >= threshold,
        language_code=language_code,
        expected_phrase=expected_phrase,
        transcript=transcript,
        similarity=round(similarity, 4),
        audio_path=audio_path,
    )

2. Creating & Persisting the Cloned Voice (client.py)

Finally, create_replicated_voice() base64-encodes both the normalised reference clip (source.wav) and consent clip (consent.wav), sends them to client.voices.create() (/v1beta/voices), and wraps the returned voice_... ID in our VoiceRecord model (which calculates the 1-year TTL expiry and gets saved to data/voices.json):

def create_replicated_voice(
    self,
    *,
    alias: str,
    display_name: str,
    source_wav_path: Path,
    consent_wav_path: Path,
    store: bool = True,
    model: str = "gemini-3.8-flash-tts",
    default_style: str | None = None,
    language_code: str = "en-GB",
) -> VoiceRecord:
    """Create a stateful (`store=True`) or stateless (`store=False`) replicated voice."""
    source_b64 = base64.b64encode(source_wav_path.read_bytes()).decode("utf-8")
    consent_b64 = base64.b64encode(consent_wav_path.read_bytes()).decode("utf-8")

    voice_payload: dict[str, Any] = {
        "model": model,
        "type": "replicated",
        "replicated": {
            "source_audio": {"mime_type": "audio/wav", "data": source_b64},
            "consent_audio": {"mime_type": "audio/wav", "data": consent_b64},
        },
    }
    if store:
        voice_payload["display_name"] = display_name

    response = self.client.voices.create(store=store, voice=voice_payload)
    return VoiceRecord(
        alias=alias,
        display_name=display_name,
        voice_type=VoiceType.REPLICATED,
        storage_mode=StorageMode.STATEFUL if store else StorageMode.STATELESS,
        voice_id=getattr(response, "id", None),
        voice_key=getattr(response, "key", None),
        model=model,
        default_style=default_style,
        language_code=language_code,
        source_audio_path=str(source_wav_path),
        consent_audio_path=str(consent_wav_path),
    )

Taking It for a Spin!

1: Cloning My Voice

To create a persistent cloned voice via the Gemini API's /v1beta/voices endpoint (client.voices.create()), we first need two short recordings:

• A Reference Audio Clip (10 to 30 seconds): Around 20 to 25 seconds of natural, expressive conversational speech so Gemini can capture your natural cadence, pitch variation, and warmth.
• The Mandatory Consent Clip: A clear recording of the same voice reciting this exact consent phrase: "I am the owner of this voice and I consent to Google using this voice to create a synthetic voice model."

I recorded these short clips using Audacity (the free, open-source audio editor) and exported them as standard 16-bit WAV files.

Now I ran these commands to prepare, create, and back up my dazbo voice:

make prep-audio ALIAS=dazbo SOURCE=data/raw/dazbo_ref.wav CONSENT=data/raw/dazbo_consent.wav
make create ALIAS=dazbo DISPLAY_NAME="Dazbo Primary"
make sync-push

• make prep-audio resamples each recording as required and sends the consent clip to gemini-3.5-transcribe, verifying a 100% word match against the mandatory statement.
• make create sends the reference and consent WAVs to client.voices.create() (store=True), which creates the persistent cloned voice in our Google Cloud project and saves the returned voice_... ID to our local voices.json catalogue under the alias dazbo.
• make sync-push backs up the catalogue and normalised WAV files to Google Cloud Storage.

2: Text-to-Speech

To prove the voice works as expected, I tested it against a short Markdown monologue script (examples/monologue.md):

"Well howdy. You're not listening to Dazbo. You're listening to his voice clone, created using gemini-3.8-flash-tts. In a few minutes, you can create your own voice clone. Enjoy!"

make speak ALIAS=dazbo FILE=examples/monologue.md OUT=output/monologue.mp3

Within a few seconds, output/monologue.mp3 was sitting in output/. Here is the full flow in action — running the make commands and playing back the synthesised voice clone:

THIS IS SO COOL!

3: Cloning a Second Voice & Demoing a Two-Person Story — The Great Pie Heist

Once the single-voice demo was proven, my wife Kate wanted to try it too. We recorded her reference and consent clips, ran the exact same make prep-audio and make create ALIAS=kate DISPLAY_NAME="Kate Primary" commands, and decided to test building a two-person conversation with our cloned voices in a single Interactions API call.

Remember at the start of this article when I told you to grab your coffee and your cat? Well, we have two cats: Leia (aka Laylay) and Mycroft (aka Mikey).

I asked Antigravity to create a 2-minute dialogue script about our kitties, in the required yaml format. It created this:

model: gemini-3.8-flash-tts
speakers:
  Dazbo: dazbo
  Kate: kate
turns:
  - speaker: Dazbo
    text: "Honestly, Kate, I think we need to stage a full-scale intervention. I went into the kitchen five minutes ago to grab a coffee, and the crime scene on the counter was just tragic."
    style: "deadpan, amused British storyteller"
  - speaker: Kate
    text: "Oh no. Don't tell me. The steak and ale pie?"
    style: "knowing, slightly exasperated but amused"
  - speaker: Dazbo
    text: "Reduced to a mere crust, my love. And right next to the tin — not even attempting to flee the scene, mind you — was Laylay. Fast asleep, with flaky pastry crumbs dusted all over her whiskers."
    style: "expressive, conversational, slightly dramatic"

# ... you get the idea! (Full 14-turn script in the repo)

And then I ran this single command:

make dialogue SCRIPT=data/scripts/laylay_and_mikey.yaml OUT=output/laylay_and_mikey.mp3

About ten seconds later, the mp3 file popped out. Check it out!

4: Using Our Cloned Voices Directly in Google AI Studio

That immediately begged the next question: "Now that we've created these voices, can I use them in the Google AI Studio web UI?"

The answer is yes! Remember earlier when I mentioned that the option to create a cloned voice wasn't showing up in the Google AI Studio UI for me in the UK? Well, because make create registers voices via the API with store=True, those voices are saved directly into the Google Cloud project's Gemini Voices catalogue — which means they immediately show up ready to use inside Google AI Studio anyway!

It's as easy as 1-2-3!

1. Open https://aistudio.google.com/generate-speech and select the GCP project where the voices were created.
2. Click + Create new dialog.
3. Pick Your Cloned Voices under Speaker Settings: In the right-hand Run settings panel under Speaker settings (or by clicking the speaker pill on any speech block), open the voice selector. Right at the very top under Custom voices — above all the built-in voices (Bodi, Lumi, Sola, Koda) — sit Dazbo Primary and Kate Primary!

That means we get the best of both worlds: a low-effort, type-and-go local CLI (make speak, make dialogue, etc.) for scripted stories, plus Google's native web experience in Google AI Studio whenever we just want to type a quick prompt and hit Run.

Wrapping Up: Come for the Voice Clones, Stay for the Harness

Building voice-replication in a single sitting proved two things for me.

First, every layer of the Google Antigravity harness paid for itself:

• Global Context (~/.gemini/GEMINI.md + Skills + MCPs) supplied the reusable engineering standards and live Google documentation before I even typed a prompt.
• Interactive Discovery (/grill-me + SPEC.md) resolved the audio normalisation, consent transcription, and Cloud Storage class trade-offs before a line of code was written.
• Self-Correcting Execution (LOOPS.md + TDD + Tier 1 & Tier 2 Gates) drove every vertical slice through Red -> Green -> Refactor, short-circuiting mechanical errors at $0 cost before a stateless Critic verified the rubric.

Second, you don't need to write any code to try this yourself. If you want to clone your own voice, script multi-speaker podcasts, or unlock your custom voices inside Google AI Studio:

1. Clone the repo: Grab derailed-dash/voice-replication on GitHub (and drop it a star ⭐ while you're there!).
2. Record two short clips: Record 20 seconds of natural speech and the mandatory consent sentence.
3. Run two commands: Run make prep-audio and make create — and within a couple of minutes, your voice clone will be ready for both terminal scripting (make speak, make dialogue) and the Google AI Studio UI!

Give it a spin, and let me know in the comments what you end up building (or which family members and pets you end up scripting dialogues about)!

Before You Go

• Please share 📢 this with anyone that you think will be interested. It might help them, and it really helps me!
• Please drop some reactions ❤️ 🦄 🔥 (you can pick more than one!) and bookmark 🔖 this post!
• Please leave a comment 💬. Interaction is good!
• Add a star ⭐ on my repos!
• Follow 👉 me here on Dev.to, so you don’t miss my content.

References and Useful Links

• Source Code Repository — derailed-dash/voice-replication
• Gemini API — Voice Replication Guide
• Gemini API — Speech Generation (TTS) Guide
• Gemini API — Voice Design Guide
• Gemini API — Audio Transcription (gemini-3.5-transcribe)
• The Loop Library & loopy Skill
• From Vibing Chaos to Reliable Agents: The What, Why, and How of Harness Engineering (Part 1)
• Loop Engineering in the Harness: Autonomous, Self-Correcting Systems (Part 2)
• Spec-Driven Development For-the-Win: Disposable Code, Living Blueprints, and Building Like a Boss (Part 3)
• Skills Sprawl: When Too Much of a Good Thing Confuses Your AI Agent
• Meet the Antigravity Extension: Gemini Code Assist on Steroids, in Whatever IDE You Love
• Dazbo's Portfolio