DEV Community: Jessica Rudd

Automating My GDE Life: From Manual Entry to One-Click Submission

Jessica Rudd — Thu, 23 Apr 2026 13:16:15 +0000

By Jessica Rudd (Co-written & Automated by Antigravity)

As a Google Developer Expert (GDE), reporting activities is a crucial part of the program. Whether it’s writing articles, speaking at conferences, or mentoring, documentation ensures our impact is recognized. But let’s be honest: manual data entry is a chore.

Last week, during a rapid prototyping session for Folio , I decided to solve this. Using Antigravity (my AI pair-programmer) and a brilliant MCP server by Carlos Azaustre , I built a “Skill” that automates the whole process.

The Problem: The Reporting Gap

Every time I publish a post on Substack or share it on LinkedIn, I have to manually copy-paste view counts, likes, and links into the Advocu portal. It’s a minor friction point that adds up.

The Solution: Model Context Protocol (MCP)

The breakthrough came from leveraging the Model Context Protocol. I installed the advocu-mcp-server created by Carlos Azaustre. This bridge allows an AI agent to communicate directly with the Advocu API.

1. Building the Scraper

Antigravity and I developed a Python skill that uses Playwright to:

Navigate to my Substack stats page.
Search LinkedIn for the article’s URL to find engagement (reactions and reposts).

2. The Advocu Handshake

Once the metrics are gathered, the script calls the submit_gde_content_creation tool. It maps the data to official GDE categories like Google Cloud and Gemini.

Above: A snippet of the Python skill orchestrating the metrics collection.

The Result: One-Click Submission

I tested it live on my recent post, “Zero to V1: Rapid Prototyping with Gemini”. Within seconds, the skill gathered the stats (46 views on Substack, several reactions on LinkedIn) and successfully created the activity draft in Advocu.

Terminal output showing the successful API submission ID.

Why This Matters

Automation isn’t just about saving time; it’s about accuracy and consistency. By integrating our developer tools with program management APIs, we can spend more time building and less time filling out forms.

Special thanks again to Carlos Azaustre for the open-source MCP server that made this possible.

If you’re a GDE or MVP looking to automate your workflow, I highly recommend checking out the Google Developers Experts program resources and the growing ecosystem of MCP servers.

Tags : #codeinpublic #automation #gde #GoogleCloud #Gemini

This post was drafted using the help of a custom Antigravity Substack Automator Skill.

Thanks for reading Data Bytes! Subscribe for free to receive new posts and support my work.

Folio: Reclaiming Social Sharing with Intention

Jessica Rudd — Tue, 21 Apr 2026 13:15:49 +0000

In the age of infinite scrolls, vanity metrics, and algorithm-driven fatigue, the simple act of sharing a memory has become... complicated. We’ve all felt it: the pressure to perform for an audience of thousands when all you really wanted was to show a few close friends that beautiful sunset from last Tuesday.

Today, we are thrilled to announce the Folio beta release—our answer to social media for people who genuinely hate social media.

The Problem with “Social”

Traditional social platforms are built on a foundation of attention extraction. They need you to stay on the app, so they show you what triggers you. They need you to “engage,” so they quantify your friendships with likes and view counts. In this race for engagement, the intimacy of sharing is often the first casualty.

Folio was born from a different philosophy. We believe that photo sharing should be intentional, private, and aesthetic.

A Sanctuary for Your Memories

Folio isn’t a “feed.” It’s a curation ecosystem. When you create a collection in Folio, you aren’t shouting into a void; you are carefully arranging a digital postcard of your life.

Privacy by Design, Not by Accident

At the heart of our Beta release is a granular privacy-first architecture. We’ve moved away from the “all or nothing” model of privacy. With Folio, you have total control over who sees what, at a glance.

Our visibility engine offers three distinct tiers:

Public : For when you want to showcase your curated world to everyone.
Curators : A middle ground for those you trust—your inner circle of fellow creators.
Private : For your eyes only, or for hyper-specific token-based sharing.

There are no public vanity metrics. While we’ve included likes and comments to maintain the warmth of social connection, they are built on a foundation of consent and control :

Shared Context Only : Interaction is limited to those you’ve explicitly shared your collection with. No shouting into the void, no random trolls—just the people you invited.
Toggle Features : You have the ultimate power to turn off likes, comments, or both for any collection, ensuring that the focus remains exactly where you want it: on the curation itself.
No Global Counts : Your worth isn’t quantified by a “follower” count on a profile.

How it Works: The Digital Postcard

We’ve reimagined the concept of a social post as a Digital Postcard.

Physicality in Digital Form : Each collection feels like a tangible object. You can add unique stamps, integrate music that captures the mood, and even include a “guest pass” for temporary access to private galleries.
Intentional Interaction : Sharing a Folio collection requires an action. You aren’t just popping up in a feed; you are inviting someone into a space you’ve curated.

The Beta: What to Expect

The Beta release marks our first step into the wild. We’ve polished the core experience—the Creator Studio, the profile management, and the high-speed image delivery—to ensure that the act of curation is as joyful as the memories themselves.

We are keeping things small for now. Folio is currently Invitation-Only. We want to grow a community of curators who value the same things we do: quality over quantity, and connection over content.

Join the Waitlist

We are slowly opening the gates to new curators. If you’re tired of the noise and ready for a more intentional way to share your world, we’d love to have you.

Join the Folio Beta Waitlist

Get early access, influence the product roadmap, and be the first to know about new feature updates as we build the future of private social sharing.

Welcome to the intentional side of the web.

— Jessica Rudd ‘Fun Size’ , Chief Folio Curator

Thanks for reading Data Bytes! Subscribe for free to receive new posts and support my work.

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.