Learning a new programming language used to take weeks of tutorials before you built anything real. A Google developer just did it in a single day, porting a working tool from TypeScript to Go while learning the language as the AI did the heavy lifting. The result was a tool that starts in 2 milliseconds and uses just 11 MB of memory. Here is how the workflow actually worked, and how you can copy it.

What This Story Is Really About

On the surface, this is about rewriting a small command-line tool in Go. The deeper lesson is a new way to learn and build with AI agents. Instead of typing every line, the developer acted as the architect and let the agent do the mechanical work.

The tool in question is called skl, used for managing AI agent skills. The original version ran on Node.js and carried the usual dependency overhead. The goal was a single, compiled Go binary that launches instantly and sips memory.

Why Go, and Not Rust or Python

Before writing code, the developer asked the AI to weigh several languages. Each had tradeoffs, and the reasoning is useful if you are choosing a stack for a fast command-line tool.

Go won because it offered a strong standard library, fast compilation, and straightforward code, which made it ideal for a cross-platform binary.

The Step by Step Workflow

The migration followed a clear sequence. You can reuse this same flow for almost any porting or learning project with an AI agent.

1. Set the goals first. Define what matters: speed, minimal dependencies, and a zero-trust security model before any code is written.
2. Ground the environment. Install community best-practice skills so the AI writes code in the language’s accepted style.
3. Plan and map. Have the agent pull the original repo, map the work, and ask questions before building.
4. Run a test-driven loop. Write tests first, let them fail, then generate code that makes them pass.
5. Parallelize big tasks. Use subagents to port many commands at once when the workload is large and well bounded.
6. Document and ship. Set up the build, continuous integration, and clear notes for both humans and future agents.

Test-Driven Development Did the Heavy Lifting

To make sure the Go version behaved exactly like the original, the developer used a test-driven development loop, often shortened to TDD. The agent wrote a test first, watched it fail, then wrote the code to pass it.

This caught a subtle but important win. By using simple text scanning instead of complex regular expressions, the new tool avoided a class of security flaw that can crash an app. Setting safety as a goal up front led the AI to write safer code than the original.

The Elephant and the Goldfish

One of the most useful ideas here is a focus pattern called the Elephant and the Goldfish. It is a simple way to manage an AI agent’s attention on a big project.

• The Elephant is the long-running coordinator that holds the design rules and remembers the whole codebase.
• The Goldfish are short-lived subagents you spawn for a single task, with no memory of past work.

Splitting work this way keeps the main agent from drowning in context while small, clean agents knock out focused jobs. For huge projects, that separation keeps quality high without burning extra resources.

The Real Takeaway: How You Learn Changes

The developer said the biggest shift was behavioral, not technical. Working through an AI agent instead of a normal code editor forced him to stay at the high level and act as the architect.

In a normal setup, the moment something breaks, your instinct is to dive in and fix it yourself. Steering an agent forces you to understand why the problem happened instead. That habit is exactly what makes you better at managing AI tools at scale. If AI-driven workflows interest you, our other AI and developer coverage digs into more of these tools.

How You Can Do the Same

You do not need this exact tool to use the approach. The pattern works with most modern AI coding agents.

1. Start with clear goals and constraints, including security, before any code.
2. Install best-practice guides so the AI follows the language’s accepted style.
3. Insist on tests and review the output yourself rather than trusting green checks.
4. Stay the architect and let the agent handle translation and boilerplate.

This story is less about Go and more about a new way to build. By setting clear goals, grounding the AI in best practices, and reviewing every step, one developer learned a language and shipped a fast, secure tool in a day. The tools will keep changing, but the habit of staying the architect while the AI does the heavy lifting is the skill worth keeping.

Read More

Google’s full walkthrough on the Cloud blog  (original developer guide)

The official Go programming language site  (independent, canonical Go resource)

The skl tool on GitHub  (open-source project from the article)

Frequently Asked Questions

What Is Antigravity 2.0

Antigravity 2.0 is an AI coding agent from Google that can plan, write, test, and migrate code while a developer sets the goals and reviews the work.

Can You Really Learn Go in a Day

You can build a working Go project in a day with AI help, but real fluency still takes practice. The approach helps you learn by doing while shipping real code.

What Is the Tool That Was Built

It is called skl, a fast command-line tool for managing AI agent skills. It was ported from TypeScript to a single compiled Go binary.

Why Choose Go for a CLI Tool

Go compiles to a fast single binary, has a rich standard library, and uses simple linear code, which makes it strong for cross-platform command-line tools.

What Is Test-Driven Development

Test-driven development, or TDD, means writing a test first, watching it fail, then writing the code to make it pass. It helps catch bugs early.

Is AI Coding Safe to Trust

AI speeds up coding, but you should always review the output and add your own tests. Passing tests alone do not guarantee correct or secure code.