Gemini helped me succeed at the horse races on Saturday. Great use of AI. In today’s list, I liked some of the leadership and mentorship content.
[blog] The AI Productivity Paradox. Instead of AI closing the gap, the best product companies are getting even further ahead. It doesn’t matter if you deliver faster if you aren’t learning what matters to users.
[article] Why Mentoring Matters More in the AI Era. Good advice. Not everyone can automatically be a mentor, as it may take training to do it effectively. But it’s well worth the investment.
[blog] Security Must Be Built In as Everyone Becomes a Builder. I don’t see this talked about enough. It’s great that everyone can build. But we (all?) need platforms with built-in guardrails and security controls to keep us safe.
I’m heading to the Del Mar Fairgrounds tomorrow to watch the horse races. Like last year, I’m going to ask Gemini to help me come up with creative, successful bets. For science, that’s all.
[blog] Governed Growth, Part 1: Better Together, Governed Apart. I can’t say I’ve ever seen this talked about. Casey does a wonderful deep dive into governance of model features, and ensuring you’re not accidentally allowing capabilities that introduce unacceptable risk.
[article] The State of AI Impact in Engineering: Q2 2026. Here’s a report based on real user data. It looks like AI code generation is up, quality might be down, and developer experience is declining. All while spend is ahead of outcomes. We’ll see how this changes, quarter to quarter.
[blog] The Rise of the Subagents. I’m glad to see smarter people building on my primitive looks at subagents. Daniela’s “agent swarms” are intriguing.
Want to get this update sent to you every day? Subscribe to my RSS feed or subscribe via email below:
You never know how a day will turn out when you’ve got a last-minute, vaguely-titled 1:1 with your CEO. It ended up being a good chat and I’ve got some fresh items to go tackle. It’s a treat working for leaders who know what they’re talking about, and want to win.
[article] Where the real competition is in AI. Fair assessment by Matt. Most of us want to be the place where AI-assisted work happens. Everything else is in service of that.
[article] The Tokens You Can’t Wait For. Interesting read about diffusion models and the mechanics of GPUs. Worth a read if you’re figuring out your AI infrastructure strategy in a way that maps to your business needs.
[blog] That You Must Suffer for Greatness is a Dangerous Lie. In virtually every case, you need to work hard to do something great. No way around that. But it can be enjoyable hard work, not necessarily “suffering.”
I’m still behind on my reading after last week’s travel, but today’s list started to clear out some of the queue. Some thought-provoking stuff today!
[article] The Open Source Agent Toolkit in 2026. Read this for a view of each layer of the stack and what open products you can pick for each. Missing the “runtime” layer?
[blog] The PR Shipped. Did the Engineer Grow? Excellent post. As a manager, how can you tell if your team is absorbing the lessons from their AI sessions, or just outsourcing the thinking? Is your team growing? Building judgement?
Maybe it’s just me, but it feels like most of the agentic coding tools out there are single-player. An individual developer engages in a coding session with one or more agents, and the non-code “exhaust” (scratch files, harness-generated session docs) stays on the local machine. Oh sure, the code gets checked into a team-visible repo, and git commit body should list all the key changes. But are teammates losing out on the “thinking” that went on during that individual coding session? Maybe those core details are in a requirements/design doc somewhere, assuming people still write those! But how are teams of developers collaborating nowadays with all this agentic coding going on? Are we sharing those session-level artifacts and creating a team “brain”?
I wondered if there was an easy way to take my Google Antigravity session artifacts and make them part of my commits. By default, any session/conversation docs—implementation plans, walkthroughs, chat transcripts—live in a machine folder. But I want those dragged into my local project folder so that they’re automatically pulled into commits, and thus visible to teammates. Then, teammates can use their own harness to understand my thinking or how I arrived at a certain decision for my code contribution.
So I wrote an agent skill. It includes a Python script that explicitly moves the files when the coding session is done. The script does a git add of those files, including the full (and summary) session transcript. Specific to Antigravity, you might also build a sidecar, or something that runs in the background and continuously works. But this was a simpler choice.
Let’s walk through the key bits. And then I’ll show it in action.
In a hidden .agents folder, I’ve got an AGENTS.md file, a skills folder that contains a skill named team-sync, and then a SKILL.md along with a Python script used by the skill.
We’ll start with the SKILL.md. It fires up as the agent finishes artifacts, and when explicitly triggered by the user.
---
name: team-sync
description: Synchronizes local Antigravity conversation history, transcripts, and artifacts (including a light summary) to the project repository for team sharing.
---
# Team-Sync Custom Skill
Use this skill to archive and upload your conversation's transcripts, artifacts, and a "light" human-readable summary into the Git repository, allowing other team members to quickly catch up on your agent steps, decisions, and outcomes.
## When to Use
* Call this skill when a coding task, implementation plan, or refactoring conversation has finished successfully.
* Run it before opening a Pull Request so that reviewers can inspect the execution logs and the conversation summary.
## Instructions for the Agent
1. **Generate the Light Transcript (`summary.md`):**
Create a file named `summary.md` in your local brain directory. The summary must follow this structure:
```markdown
# Conversation Summary: [Objective/Topic]
* **Date:** [Current Date]
* **Conversation ID:** [ANTIGRAVITY_CONVERSATION_ID]
## TL;DR
[A 1-2 sentence high-level summary of what was accomplished]
## Key Decisions & Rationale
* **Decision:** [e.g., Using Python's shutil instead of bash commands]
* **Why:** [e.g., Cross-platform safety and better permission handling]
## Most Interesting Event / "Aha" Moment
[Capture any major back-and-forth conversation, user course corrections, pivot points, or model/user "aha" moments that defined the flow of this conversation.]
## Scope of Changes
* **Files Modified/Created:** [List of files]
* **Verification:** [How the changes were validated, command outputs, etc.]
## Learnings & Gotchas for the Team
* [Any lessons learned about the API, codebase, or environment that others should know]
```
2. **Verify Environment:**
Ensure `ANTIGRAVITY_CONVERSATION_ID` is set in the environment.
3. **Execute Sync Script:**
Run the sync helper script:
```bash
python3 .agents/skills/team-sync/scripts/sync.py
```
*Note: Because `sync.py` automatically copies all `.md` files, your newly created `summary.md` will be synced to the workspace repository automatically.*
4. **Report Status:**
Confirm to the user that the summary and files have been successfully synced.
The Python script does the work of actually copying files from Antigravity’s “brain” folder into my local project folder.
#!/usr/bin/env python3
import os
import sys
import shutil
import subprocess
from pathlib import Path
def get_project_root() -> Path:
# Find project root by looking for .agents or .git starting from CWD
current = Path.cwd().resolve()
for parent in [current] + list(current.parents):
if (parent / ".agents").is_dir() or (parent / ".git").is_dir():
return parent
return current
def find_most_recent_conversation(brain_root: Path) -> str:
"""Finds the most recently modified conversation subdirectory in the brain cache."""
if not brain_root.is_dir():
return None
subdirs = []
for p in brain_root.iterdir():
# Conversation directories are 36-char UUIDs (plus optional custom name directories)
if p.is_dir() and p.name != "scratch":
try:
mtime = p.stat().st_mtime
subdirs.append((mtime, p.name))
except OSError:
continue
if not subdirs:
return None
# Sort by modification time, newest first
subdirs.sort(key=lambda x: x[0], reverse=True)
return subdirs[0][1]
def check_git_installed() -> bool:
"""Checks if git command-line tool is installed and available in PATH."""
return shutil.which("git") is not None
def main():
print("=== Antigravity Team Sync ===")
home_dir = Path.home()
brain_root = home_dir / ".gemini" / "antigravity" / "brain"
# 1. Retrieve conversation ID from environment or fallback
conv_id = os.environ.get("ANTIGRAVITY_CONVERSATION_ID")
if not conv_id:
print("Notice: ANTIGRAVITY_CONVERSATION_ID env variable is not set.", file=sys.stderr)
print("Attempting to auto-detect the most recent local conversation...", file=sys.stderr)
conv_id = find_most_recent_conversation(brain_root)
if not conv_id:
print("ERROR: Could not locate any local conversation histories.", file=sys.stderr)
sys.exit(1)
print(f"Auto-detected conversation: {conv_id}")
else:
print(f"Active Conversation ID: {conv_id}")
# 2. Define source paths
source_brain_dir = brain_root / conv_id
if not source_brain_dir.is_dir():
print(f"ERROR: Local conversation directory not found at: {source_brain_dir}", file=sys.stderr)
sys.exit(1)
# 3. Define target paths
proj_root = get_project_root()
target_history_dir = proj_root / ".antigravity" / "history" / conv_id
print(f"Source Directory: {source_brain_dir}")
print(f"Target Directory: {target_history_dir}")
# Create target directory
try:
target_history_dir.mkdir(parents=True, exist_ok=True)
except PermissionError:
print(f"ERROR: Permission denied. Cannot write to target directory: {target_history_dir}", file=sys.stderr)
sys.exit(1)
except Exception as e:
print(f"ERROR: Failed to create target directory: {e}", file=sys.stderr)
sys.exit(1)
# 4. Copy Artifacts (markdown files and media in the main directory)
copied_count = 0
for file_path in source_brain_dir.iterdir():
if file_path.is_file() and file_path.suffix in [".md", ".png", ".jpg", ".jpeg", ".gif", ".mp4", ".mov"]:
try:
shutil.copy2(file_path, target_history_dir / file_path.name)
print(f"-> Copied file: {file_path.name}")
copied_count += 1
except PermissionError:
print(f"Warning: Permission denied copying file {file_path.name}")
except Exception as e:
print(f"Warning: Failed to copy {file_path.name}: {e}")
# 5. Copy Transcripts
logs_dir = source_brain_dir / ".system_generated" / "logs"
transcript_copied = False
if logs_dir.is_dir():
for log_file in ["transcript.jsonl", "transcript_full.jsonl"]:
source_log = logs_dir / log_file
if source_log.is_file():
try:
shutil.copy2(source_log, target_history_dir / log_file)
print(f"-> Copied log: {log_file}")
transcript_copied = True
except PermissionError:
print(f"Warning: Permission denied copying log {log_file}")
except Exception as e:
print(f"Warning: Failed to copy log {log_file}: {e}")
if not transcript_copied:
print("Warning: No transcript files found in the conversation logs.")
# 6. Git Synchronization
git_dir = proj_root / ".git"
if git_dir.is_dir():
if not check_git_installed():
print("\nWarning: Git repository detected, but git executable is not available in your PATH. Skipping Git commit.")
print("Sync completed successfully!")
return
try:
print("\nStaging files in Git...")
subprocess.run(["git", "add", str(target_history_dir)], check=True, cwd=proj_root)
print("Conversation history and transcripts staged in Git successfully!")
print("You can now commit these staged history files together with your code updates.")
except subprocess.CalledProcessError as e:
print(f"\nWarning: Git command failed with error code {e.returncode}.", file=sys.stderr)
print("Your files have been successfully copied locally, but could not be staged automatically in Git.", file=sys.stderr)
else:
print("\nNote: Not a Git repository (or .git not found). Skipping Git commit.")
print("\nSync completed successfully!")
if __name__ == "__main__":
main()
And finally, my AGENTS.md is quite simple and tells my harness when to mirror the core coding session artifacts.
# Team Customization Rules
These rules govern how Antigravity agents operate within this project repository to facilitate seamless team collaboration.
## 1. Artifact Mirroring
To ensure that all design decisions, test verifications, and walkthroughs are visible to the team during code reviews:
* **Mirroring Rule:** Whenever you create or modify an artifact (such as `implementation_plan.md`, `task.md`, or `walkthrough.md`) in the local user cache directory (`~/.gemini/antigravity/brain/<conversation-id>`), you MUST copy or write a duplicate version of that file to the workspace under `.antigravity/history/<conversation-id>/`.
* **Git Commits:** These mirrored documents should be staged and committed to Git alongside the source code changes.
## 2. Conversation Telemetry & Syncing
* If the user or agent needs to share the raw execution logs, terminal outputs, and thinking transcripts of a conversation:
* Run the `team-sync` skill at the end of the session.
* This will execute the `sync.py` script to collect the finalized `transcript.jsonl` and copy it to the same `.antigravity/history/<conversation-id>/` directory.
This .agents folder could be part of some shared Git project or project-bootstrapping script. Here’s an example of how to use it.
I created a local directory for my new coding project. Maybe I’m the first one on my team working on it. After copying the .agents folder into that directory, and running a git init, I opened Google Antigravity and started a new session/conversation. Notice that my Antigravity settings for this project shows the skill and agent rules loaded up automatically.
At this point, I just did my work like always. I used Antigravity to build a Dart and Flutter-based web app for my fictitious hotel chain. I built this (and packaged it) over three distinct coding sessions.
As each session went along, I noticed the session artifacts (like implementation plans and walkthroughs) showing up in the .antigravity folder within my project directory. And I ended each session with a request to run the team-sync skill. That ensured that my final chat transcript(s) showed up too.
Let’s imagine that I’ve pushed all my changes into a team-shared repo. The next developer(s) can pull down the app code, along with the session history. Maybe they’re curious about how we arrived at our deployment choice. For example:
Review the summary transcripts in this project and help me understand how the team decided to deploy to Cloud Run instead of Kubernetes.
The result? The transcript summary is consulted and the developer sees the results of the conversation and trade-offs factored in.
These key architectural decisions should be in other stateful artifacts like design docs. But given how fast teams are running now, the “requirements” are sprinkled throughout the code, test plans, session artifacts, and upfront docs.
Maybe I’m solving a temporary problem and within weeks, all these coding tools will make it super easy to create a shared “brain” for software teams. But for now, I like that agent skills make it easy to extend Antigravity this way. How are you thinking about sharing “thinking” among your developers?
My team runs a program where we spend a week with a customer taking a use case from idea to MVP. The team (and customer) came to San Diego this week so that I could be part of the exercise. It’s super cool to watch a group come together quickly to iterate, learn, and ship.
[blog] The LLM Critics Are Right. I Use LLMs Anyway. Most smart people I know aren’t ignorant of the complaints or problems with LLMs. But that doesn’t mean LLMs aren’t still useful.
[article] Are PMs becoming irrelevant? The old PM role is mostly irrelevant, I agree. The advice here is to become a strategic PM (not an “AI PM”).
On my first normal workday in a week-and-a-half, it was mostly all meetings. Lots of catch up. But I got to spend the last bit of the day working on a presentation about “how to use AI without losing your soul.” You can tune into it on Wednesday if you’d like!
[blog] Earning taste and judgment. Worried that recent college grads are either unemployed or underemployed? You should be. Addy looks at what humans are uniquely good at (taste/judgement) and how early-career people that build it up.
[blog] Evals belong in your CI/CD pipeline. I’m a sucker for opinionated statements like this. Gets my attention. This is reasonable advice. Although, my evals haven’t been super fast, so I wonder if you’d run them on every build.
[blog] Turn User Signal Into What You Build Next. It might not just be about mixing up the SDLC stages. Rather, it’s putting “user feedback” higher on the priority list and putting prototypes/variants in the hands of users faster.
[blog] The Risk of Exposed Cloud Functions and How to Harden. The serverless hype train has reached the station, but that doesn’t mean many of us don’t still build scale-to-zero apps and functions. These are real concerns to mitigate.
[blog] Designing APIs for Agents. Don’t just cater to humans and what we can comprehend. This piece encourages us to think differently for our AI consumers.
Just got home after a 24+ hour travel day back from India. No wifi on the second (11 hour) segment, so I’ll have some catching up to do! Great trip, though.
[blog] What 10 autonomous film crews taught us about agent teamwork. This might be the wildest thing you read all week. What happens when you create film crews out of AI agents, and then assign an AI documentary crew to capture the journey? You get this.
[article] How I Cut an AI Agent’s Token Use by 94%. Super smart. Over time, you might realize that your natural language agent skill can be “compiled” into a deterministic script.
[blog] NotebookLM is now Gemini Notebook. We like renaming things. This product keeps getting better and more integrated, so I get the reasoning.
[blog] Kimi K3: Open Frontier Intelligence. Yeesh, you could make the case that this is now the best coding model, and it’s an open one. Running this yourself is fairly impractical (for now), but I imagine the API will be super popular.
[blog] Model Routing Is Simple. Until It Isn’t. Some interesting perspective up on the Hugging Face blog. You’ll increasingly crave a model router. But there’s more to it than you think.
It’s my final day in India, as I fly home in a few hours (3am local time). Great trip. I’ve got a pile of things to think about, and another handful of things to go build.
[article] The Prototype Is a Question, Not a Product. Just because we can do lightning-fast prototypes now, it doesn’t mean we shouldn’t have a strong hypothesis and scorecard before we start. Great reminder here.
[blog] Which Doc Format is Best for AI Specifications? I had to regroup after reading the first sentence—that’s a LOT of specs. It seems we’re still figuring out which document formats represent the best way to transmit and store agent-friendly data.
[article] The Frontend Verification Gap in AI-Assisted Development. Your favorite AI tool probably creates some very nice looking frontend UIs. What does “correctness” look like though, and how do you test the frontend’s behavior?
Our Google Developer Expert community is pretty remarkable. 8% of them are in India, and I got to spend all day today with them. And, I also snuck in some experimentation with agent skills.
[article] The AI Didn’t Fail. The Deployment Did. That AI-powered café almost went bankrupt. Was it because the model went crazy? No. Casey shows that the AI didn’t have the context, guardrails, and memory that a competent builder would include.
[blog] Control the ideas, not the code. You’ve got a limited number of usable hours in the day. Salvatore has a post worth reading and contemplating.
[blog] You Just Hired a Million Bad Employees. There are like six hot takes in this post. Are humans now cheaper than software? This seems to assume that token costs will remain flat. But there’s an important point here about wasted cycles.
Richard Seroter's Architecture Musings 