Moving Fast Without Losing Track: My antigravity-cli Changelog Habit

#agenticarchitect #antigravity #google #adk

As a consultant, I am used to working at different speeds.

At the beginning of a project, especially when preparing the first proof of concept, the pace is fast. Very fast. It feels close to startup mode: short feedback loops, quick decisions, and a strong focus on delivering something usable in the shortest possible time. The goal is not to build the final version immediately. The goal is to test an idea, reduce uncertainty, and put something concrete in front of people.

In that phase, speed matters more than ceremony. A proof of concept gives the team real evidence: does the workflow make sense, does the model answer correctly, does the tool integration work, does the user understand the value?

But after the POC works, things change.

Once the first version is tested and released to production, the project enters a different rhythm. The code is no longer only an experiment. It becomes something users depend on. Every change can affect a real workflow, so the team needs more control over what will go live.

This is why, with atigravity-cli, I usually add a skill that updates the changelog after every modification. It is a small habit, but it creates a useful control layer. Each code change leaves a written trace.

Here is a simple example from my Google ADK TypeScript project. The root agent is a sequential ADK workflow: first it converts currency, then it estimates how many LEGO pieces could be bought.

import { SequentialAgent } from "@google/adk";
import { currencyAgent } from "./sub-agents/currencyAgent.ts";
import { legoPiecesAgent } from "./sub-agents/legoPiecesAgent.ts";

export const rootAgent = new SequentialAgent({
  name: "currency_pipeline",
  description:
    "Converts currency, then calculates LEGO pieces needed for the converted amount.",
  subAgents: [currencyAgent, legoPiecesAgent],
});

This is still a small project, but it already has a structure that can grow: a root agent, sub-agents, tools, a README, and a changelog. The currency agent is focused on one job only.

export const currencyAgent = new LlmAgent({
  name: "currency_agent",
  model: "gemini-3.5-flash",
  description: "An agent that can help with currency conversions.",
  instruction: `${SYSTEM_INSTRUCTION} When converting an amount, clearly include the final converted amount and target currency in your response.`,
  tools: [getExchangeRate],
  outputKey: "currencyResult",
});

The tool itself calls the Frankfurter API and keeps the external integration isolated.

const url = new URL(`https://api.frankfurter.app/${currency_date}`);
url.searchParams.set("from", currency_from.toUpperCase());
url.searchParams.set("to", currency_to.toUpperCase());

const response = await fetch(url);

Then another agent reads the conversion result and calculates a LEGO estimate. In the example, the logic supports USD and EUR.

If the target currency is EUR,
estimate LEGO pieces using the average retail price range for a new LEGO piece:
EUR0.10 to EUR0.13 EUR per piece.

This kind of change may look small. But in production, even small changes matter. Supporting EUR in the LEGO estimation changes the behavior users see. With a changelog, it becomes visible.

The project includes a custom rule:

After you modify, add, or delete any files in the workspace,
trigger and follow the update-changelog skill.

And the skill defines the process:

Check which files were modified, read package.json,
read CHANGELOG.md, then write clear user-facing bullet points.

The result is simple but powerful:

For me, this is the difference between moving fast and moving blind. During the POC, I want maximum speed. After production, I still want speed, but with memory.

That context helps consultants, developers, stakeholders, and future maintainers. It turns an AI-assisted workflow into something easier to review, easier to release, and easier to trust.

You can follow me on GitHub, where I'm creating cool projects.

I hope you enjoyed this article, until next time 👋