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?
Managers have been disproportionate casualties of the rolling waves of post-COVID-19 tech layoffs that started in late 2022. Popularized by large companies such as Meta, Google, and Amazon, phrases like “flattening the org” and “reducing bureaucracy” are now synonymous with thinning the management layers that ballooned during the 2021–2022 hiring sprees. Retrospectively, such flattening can seem prescient given that AI models can now automate schedules, draft performance reviews, coordinate communication across teams, and aid in the prioritization and decision support typical of management. Pushed to the experimental extreme, this can now mean 50 ICs reporting into one supervisor. The logic here is simple and stark: since AI can, or will soon, be able to handle a lot of what managers used to do, fewer managers are necessary. Instead, decision making can be distributed within teams as individual contributors become more adept at orchestrating and supervising agentic workflows with increasingly refined judgment and decreased reliance on managerial oversight. Everyone, in effect, is a manager now.
The problem with this narrative is that organizations are reducing managers at precisely the time they are becoming increasingly important to realizing their AI investments. Several sources of recent data back this up. A main conclusion from Microsoft’s 2026 Work Trend Index Annual Report is that “organizational factors—culture, manager support, talent practices—account for twice the reported AI impact of individual effort alone.” Once leadership sets AI strategy and incentives, “…it’s managers who operationalize it, and the data shows the impact of their ability to do so.” Specifically,
…when managers actively modeled AI use, employees reported a 17-point lift in reported AI value, a 22-point lift in critical thinking about their AI use, and a 30-point lift in trust in agentic AI. When managers created psychological safety around experimentation, employees reported up to 20 points higher AI readiness and value—and were 1.4x more likely to be high-frequency users of agentic AI.
The impact of managers is even greater on more advanced AI users, what Microsoft calls “Frontier Professionals” (16% of those surveyed, users who “use agents for multi-step workflows and building multi-agent systems”). This group is more likely to report that their manager uses AI (85% vs. 64%), establishes quality standards for AI work (83% vs. 57%), encourages experimentation (84% vs. 61%), and rewards work redesign regardless of outcome (26% vs. 11%). The report notes that “in many cases, employees are moving faster than the organization around them.” Microsoft calls this the “Transformation Paradox.” According to the Microsoft data, managers are the layer that helps resolve it. They translate organizational strategy into team practices that let individual work with AI produce value.
Of course, once AI adoption is the norm and managers no longer need to manage that change, one could argue that many aspects of the role remain susceptible to automation and the role will contract. We don’t know how this will play out yet, but if management roles were already contracting we would expect to see early signs, and the data shows the opposite. LeadDev’s Engineering Leadership Report 2026 surveyed 600 engineering leaders, 55% of whom are engineering managers or managers of managers. The report notes that “AI is simultaneously expanding what leaders can do technically and what is expected of them organizationally, without reducing the demands on their time in either dimension.” Not only are managers becoming more hands-on technically,
63% of engineering leaders say their scope and area of responsibility increased over the past 12 months.
60% saw increased communication with team members, customers, and stakeholders.
22% have more teams reporting to them.
29% have more direct reports.
Architectural decisions and technical strategy saw the most respondents citing increased time dedicated to it.
One way to interpret these figures is to say that more teams and more reports show flattening working as planned from a business perspective. Another reading—not mutually exclusive—is that the role is in transition and most organizations have not fully wrestled with what that involves: managers doing their old work at greater scale, and the new work of making AI a core team practice. Either way, that’s not contraction. Contraction would mean the scope of the role itself is shrinking as AI and ICs absorb more of the work. More teams and more reports is what flattening produces, not evidence the role is going away.
To be clear, none of this means organizations should stop scrutinizing reporting structures and removing genuinely unhelpful layers of bureaucracy that stifle decision making. But it does mean asking a harder question before the next round of cuts: are you reducing management based on what managers used to do or based on the critical work they are doing now or will need to do next?
The “what they used to do” answer treats managers like overhead. The emerging evidence suggests that managers are currently playing the role of infrastructure, the critical layer that translates AI investment into actual value at the team level. Flattening on the assumption that AI will facilitate its own adoption or that value will emerge from unguided individual effort is making a productivity bet that the data doesn’t support.
Microsoft has finally begun replacing the decades-old File Explorer Properties dialog with a modern version as part of the company’s efforts to modernize Windows 11. Thankfully, the new Properties dialog is built using the native WinUI framework, and we’re not seeing any traces of a WebView2-based shell.
Right now, the Properties dialog is native to the Win32 comctl32.dll (Common Controls library), which first shipped with Windows 95. Of course, it has improved visually over the past several years, but the underlying code hasn’t drastically changed.
Microsoft previously confirmed it’ll replace all legacy dialogs with modern versions, including those from Windows 8 and even the Windows 95 era. It’s been unclear when a major Windows design update would begin rolling out, but we’re now seeing early signs in preview builds.
Microsoft watcher PhantomOfEarth found a new Properties dialog in preview builds, and unlike the existing implementation, the new version supports dark mode.
Moreover, it’s clearly built using WinUI 3 rather than a Win32 property sheet. Microsoft is not mixing the two frameworks, as I can confirm it’s entirely WinUI 3.
For example, if you look closely, the “General” tab uses a Pivot-style header and supports an accent indicator, which is only found in the WinUI 3 framework. You don’t have that in Win32, where the Properties dialog uses SysTabControl32, which is part of comctl32. Likewise, the Restore button uses AccentButtonStyle.
Finally, you have new checkboxes that follow WinUI 3 guidelines with rounded corners. It’s subtle, but it’s necessary for design consistency.
Microsoft is planning to drop the classic Properties dialog entirely, which is quite interesting because the dialog has been part of Windows for almost three decades. The existing Properties dialog was built on the Windows 95-era property sheet API (PROPSHEETPAGE, SHOpenPropSheet out of shell32) and lacked dark mode and modern accessibility features.
Why Microsoft can’t just randomly modernize Windows 11 components and call it a day
Windows is a legacy operating system, and that’s also part of the reason why the company tried building editions like Windows 10X in the past. Windows is difficult to modernize without breaking backward compatibility.
That also means Microsoft can’t just slap a modern design on the Win32-based Properties dialog and not expect third-party apps to break.
Microsoft has a responsibility to support decades-old software, which is why you can download an app or game made for Windows 95 and still run it on Windows 11. That backward compatibility approach also applies to Properties and other legacy dialogs and property sheets, where any change could break existing integrations.
Right now, third-party apps often inject tabs into the Properties dialog using IShellPropSheetExt.
Microsoft’s documentation describes IShellPropSheetExt as an interface that “allows a property sheet handler to add or replace pages in the property sheet displayed for a file object.”
When apps use the extension to add a tab to the Win32 property-sheet system, each page is created as a traditional dialog and handed back to the Windows Shell.
This includes third-party antivirus software, 7-Zip, Dropbox, codec packs, and so on, all of which hand back an HWND-based page.
Microsoft is replacing the Win32 Properties host with WinUI, and it needs a reverse-islanding path to embed those legacy HWNDs inside the new tab strip, or those extensions will break. The above screenshot shows a Recycle Bin item, which only has a General tab, but that’s not the case for other programs.
For example, if you right-click certain apps and go to their Properties, you’ll see Security, Details, Previous Versions, and even third-party tabs coexisting. It’s unclear how Microsoft is integrating those legacy third-party tabs, but I assume it has figured out how to reverse-island the path.
My other concern is that WinUI surfaces have historically paid a cold-start cost when loading the runtime. Even today, File Explorer’s WinUI context menu gets criticized for exactly that. The WinUI-based Home tab in File Explorer is slower than “This PC,” which does not use WinUI.
All of that should improve soon, as Microsoft has plans to optimize WinUI 3, and that could explain why the revamp is taking longer than usual.
Folktales are living records of culture, identity, and collective memory. In the fourth episode of our special six-part series on Vanishing Culture, host Vida Vojić speaks with writer and researcher Helen Nde, founder of Mythological Africans, and folklorist Laura Gibbs about the importance of preserving African folklore in the digital age. Together, they explore how stories help communities understand themselves, pass down knowledge across generations, and make sense of a changing world.
There's a cognitive trick our brains play whenever we face a hard question or a difficult decision: we quietly swap the hard thing for something easier to answer. It's called substitution, and we do it constantly — usually without noticing, and sometimes to our detriment. In today's episode, I make the case that you can take this same shortcut your brain already runs automatically and start using it intentionally to break decision paralysis and get moving.
The Substitution Heuristic: Understand the mental move at the heart of this episode — when "How are you?" becomes "Is there anything I urgently need to say?", your brain isn't being lazy, it's compressing. It runs a quick calculation: what's the downside of the substitute? Usually it's low, so the shortcut holds.
Code Review as Substitution: See why you almost never review a big PR line by line. "Was it tested? Does it follow our best practices? Does anything look obviously wrong?" are all stand-ins for the harder, mostly-unnecessary work of reading every line — and most of the time, they're enough.
Performance Reviews Are a Best Guess: Recognize that your rubrics, metrics, and frameworks are themselves substitutes. You can't deterministically rate a person on a scale, so every measure you use is an approximation of an immeasurable question: how much value is this person really generating, and where are they headed?
Turn the Trick Around on Purpose: Learn how to use substitution deliberately to defeat paralysis. Instead of "I'm deciding to leave my job and chase something new," substitute "I'm going to send an email." The weight of sending an email is tiny — and the dream job is just a series of small, iterative steps like that one.
Unbundle Your Big Decisions: Notice how we fuse trivial mechanical actions with heavy imagined meaning. Merging a branch isn't "declaring this production-ready and putting my name on the line" — it's moving bits into the cloud. Separate the labeling from the action and the action gets a lot less intimidating.
Lower Your Commitment Threshold: Swap "this code is great" for "I believe this code is shippable." Swap "this is the perfect hire" for "this is a good bet we can course-correct." The actions you take are identical — but the internal stakes, and the fear, drop dramatically.
Favor Reversible Moves: We consistently overestimate the risk of acting and underestimate the risk of doing nothing. Most decisions aren't permanent — you can roll back the deploy, divert from a bad hire, find an exit path. Look for the way back, and the decision gets easier to make.
Episode Homework
Next time you feel a big decision looming, break it into its most fundamental pieces. Ask: what am I actually doing here? What are the physical actions, the words, the mechanical steps? What's the true worst-case downside — and do I really have to attach all of my worth to it? You're likely already substituting easier questions without realizing it. This week, try doing it on purpose.
📮 Ask a Question
If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com.
If you want to be a part of a supportive community of engineers (non-engineers welcome!) working to improve their lives and careers, join us on the Developer Tea Discord community today!
🗞️ Subscribe to The Tea Break
We are developing a brand new newsletter called The Tea Break! You can be the first in line to receive it by entering your email directly over at developertea.com.
🧡 Leave a Review
If you're enjoying the show and want to support the content head over to iTunes and leave a review!
Log in
