Zero to V1

Jessica Rudd — Mon, 06 Apr 2026 12:03:17 +0000

We’ve all been there: a great app idea strikes while you’re mid-commute, but the gap between “cool idea” and “working prototype” often feels like an insurmountable wall of boilerplate and UI design.

In this “Data Byte,” we’re breaking down a high-speed workflow that turns scattered notes into a functional V1 in minutes. We’re building Folio —a privacy-first social app for digital postcards—using the new agentic trifecta: AI Studio , Stitch , and Antigravity.

Step 1: The Blueprint with Gemini 3 Flash

Every project starts with a spark. I use Apple Notes and Siri to capture my scattered thoughts, but the real magic begins in Google AI Studio.

I fed my raw notes into Gemini 3 Flash. Because Flash is optimized for speed and high-volume reasoning, it’s the perfect engine to distill messy ideas into structured prompts. I asked it for two specific outputs:

A Stitch design prompt to define the visual “vibe.”
An Antigravity implementation prompt to handle the technical build.

Leveraging Gemini 3 Flash in AI Studio to generate development prompts.

Step 2: “Vibe Designing” in Stitch (Gemini 3.1 Pro)

Next, I headed to Stitch to bring Folio’s “Premium Editorial” aesthetic to life.

Using Gemini 3.1 Pro within Stitch, I pasted the first prompt. Within seconds, it generated a gorgeous creator dashboard and a mobile-optimized gallery. The “vibe design” approach is a game-changer—you can iterate in plain English. I simply asked for a messaging feature, and 3.1 Pro updated the entire design system to include a refined chat interface.

Paste your prompt, make changes, add designs

Adding comprehensive messaging and chat interfaces in Stitch..

Step 3: Zero-Boilerplate Build in Antigravity (Gemini 3.1 Pro)

With the design locked, it was time to move to Antigravity , Google’s agentic IDE.

I opened the Agent Manager and pasted the second prompt.

Create a new workspace in the Antigravity agent manager and paste prompt 2 from AI Studio.

Using Gemini 3.1 Pro , the agent analyzed the design from Stitch and drafted a full implementation plan. It automatically handled:

Scaffolding a Next.js project.
Integrating Firebase Auth for secure logins.
Setting up Firestore for postcard storage.

Antigravity’s Agent Manager mapping the design to a Next.js architecture.

Within minutes, the agent finished the heavy lifting, and the app was running on localhost.

Success! The functional V1 of Folio is live on localhost.

The Takeaway

By offloading prompt engineering to Gemini 3 Flash and the complex execution to Gemini 3.1 Pro , the path from idea to execution is now a straight line. By the time I finished my morning coffee, Folio was a working application ready for its first users.

What’s next? I’ll be using the Firebase Console and Google Cloud to move this from localhost to the world.

Stay tuned for the next byte!

Building funsize-engineer

Jessica Rudd — Tue, 20 Jan 2026 22:13:31 +0000

Introduction

In the modern software landscape, the barrier between an idea and a deployable artifact is often the friction of boilerplate and configuration. This post documents the creation of funsize-engineer, a Python package designed to serve as my terminal-based “business card”. Inspired by David Neal’s npm calling card, I wanted to create a Python equivalent that could be easily distributed and run via PyPI.The goal was simple: create a distributable Python package that, when run, displays professional contact information and ASCII art in a visually appealing format. However, the method of creation was novel. Instead of writing every line of code manually, I utilized Google Antigravity, an agentic coding platform. This article demonstrates how the “Agent-First” development paradigm shifts the engineer’s role from typist to architect, focusing on task orchestration and verification rather than syntax.

Antigravity Core Functionality

Antigravity operates on a fundamental shift in the developer-tool relationship. It is not merely an autocomplete engine; it is an autonomous agent capable of executing complex, multi-step tasks.

Two core components enable this workflow:

The Manager View: Unlike a standard chat interface, Antigravity maintains a structured “Manager View” of the project. It tracks high-level objectives, breaks them down into sub-tasks (e.g., “Scaffold Repository”, “Implement Core Logic”, “Configure CI/CD”), and maintains context across the entire development lifecycle. This allows the agent to “remember” architectural decisions made in step one while executing step ten.

Artifact-Driven Workflow: The agent does not just stream code into a void. It generates Artifacts—structured documents like Implementation Plans, Task Lists, and Code Diffs. These artifacts serve as checkpoints. The agent proposes a plan, the engineer reviews and approves it, and only then does the agent execute. This “Human-in-the-Loop” model ensures that autonomy does not come at the cost of control.

The Package Creation Workflow

The development of funsize-engineer followed a structured lifecycle, orchestrated by the agent.

Phase 1: Planning and Scaffolding

The project began with a high-level directive. The agent analyzed the requirements—a Python package, rich library for UI, and PyPI distribution—and generated an implementation plan. It then scaffolded the directory structure, creating pyproject.toml for modern standards-compliant packaging and setting up the initial git repository.

Phase 2: Core Logic Development

With the foundation in place, the agent implemented the core functionality in funsize_engineer/card.py. It utilized the rich library to create a grid layout, integrating ASCII art loaded from an asset file and styling the text with specific color tokens (e.g., #8A2BE2 for branding).

Phase 3: CI/CD and Versioning

The most complex phase involved automating the release process. The agent configured GitHub Actions workflows to handle dual publishing streams:

TestPyPI: For development snapshots from the develop branch.
PyPI: For stable releases from the main branch.

Agentic Artifact Review: Validating the Workflow

A critical moment in the project was the configuration of the CI/CD pipeline. The agent proposed a GitHub Actions workflow to automate publishing.

Initial Plan Artifact (Excerpt):

Task: Configure GitHub Actions for PyPI publishing.
Action: Create .github/workflows/publish.yml.
Developer Review: Required.

Code Diff (Excerpt):

This artifact allowed the developer to verify that the workflow was correctly targeting both branches and, crucially, that fetch-depth: 0 was included to ensure setuptools-scm could correctly calculate versions from git tags.

Troubleshooting and Iteration

No development process is without friction. We encountered two significant technical hurdles that required agentic problem-solving.

1. The “Dev Version” Trap

During the setup of the automated versioning, we encountered an issue where releases from the main branch were being tagged with “dev” suffixes (e.g., 0.2.11.dev0) instead of clean release versions, despite having a correct git tag (e.g., v0.2.11).

The Issue: setuptools-scm calculates versions based on the distance from the last tag. In our GitHub Actions workflow, we were creating a tag and then checking it out. However, setuptools-scm saw the commit after the tag (the one triggering the workflow) and assumed it was a “dirty” state, appending a .dev suffix. Additionally, the workflow wasn’t properly stripping the v prefix from tags before passing them to the build system.

The Resolution: The agent diagnosed the issue and implemented a robust fix:

Explicit Versioning: Instead of relying on git state, we forced setuptools-scm to use the exact version we wanted by setting the SETUPTOOLS_SCM_PRETEND_VERSION environment variable.
Prefix Handling: We added logic to strip the v prefix from git tags (e.g., v0.2.11 -> 0.2.11) to ensure Python package compatibility.

2. Rendering Diagrams on GitHub Pages

We wanted to include a Mermaid.js diagram to visualize the agentic workflow. However, GitHub Pages (via Jekyll) rendered the mermaid code blocks as raw text instead of diagrams.

The Fix: The agent identified that the default markdown code block syntax ( `mermaid ) wasn’t being processed by the Mermaid JavaScript library. We switched to using raw HTML <pre class=”mermaid”> tags, which allowed the diagram to render perfectly without requiring complex Jekyll plugins.

Final Code & Output

The result is a lightweight, installable package. The core logic resides in funsize_engineer/card.py, which orchestrates the rich components.

Final Example Code:

Example Output:

Running pipx run funsize-engineer now renders the following in the terminal:

Conclusion

The creation of funsize-engineer highlights the power of the Agent-First methodology. By offloading the implementation details—from directory scaffolding to complex CI/CD scripting—to Antigravity, I was able to focus on the what and why of the product. The result is a professional-grade Python package built in a fraction of the time, with the agent acting not just as a coder, but as a partner in the engineering process.

Forem: Jessica Rudd