Sometimes the best solutions come from scratching your own itch. Automotan Tags started as a simple internal utility at Robokeys, but evolved into something I believe could transform how we all work with code generation and AI.
The Beginning: A Codegen Problem
Like many developers, I was tired of writing boilerplate. So I built internal code generators using tools like Plop and custom scripts. But I kept hitting the same wall:
How do you tell a generator where it’s safe to insert code?
You could use markers like <!-- INSERT HERE -->, but every tool had its own syntax. Spring Boot generators used one pattern, our custom tools used another, and frontend scaffolding used something else entirely. It was chaos.
The First Insight: Universal Structure Markers
That’s when I created the first version of what would become Robokeytags, to use at Robokeys. I used puzzle piece emoji (🧩) because:
- They’re visual and hard to miss
- They represent how code pieces fit together
- They work in any language’s comments
- They’re just Unicode – no special tooling needed
The 🧩 tags became our universal language for code structure:
// [🧩 Section: routes/primary]
// [🧩 Point: route-insertion]
// [🧩 Region: NonEditable: generated-imports]Suddenly, ALL our tools could understand the same structure. Plop knew where to insert. Our custom generators knew what to preserve. It was like giving all our tools the same map.
The Second Insight: Human Context Matters
As the system grew, we realized we needed a way to add human context that tools would respect but not process. Enter the 📌 (pin) tags:
// [📌 Note: This uses the CEO's special report format - DO NOT CHANGE]
// [📌 TODO: Refactor after Q2 when we deprecate the legacy API]These weren’t instructions for tools – they were notes for humans. But crucially, tools knew to preserve them.
The Game Changer: AI Enters the Picture
Then came the AI coding boom. Suddenly, I’m working with Claude, GPT-4, and other assistants. And I realized: they had the same problem my code generators did, but worse.
AI assistants are incredibly powerful but have the memory of a goldfish. Every conversation starts fresh. They can’t remember:
- What patterns they detected last time
- Which code sections they’re uncertain about
- What they learned about your codebase
The Third Insight: AI Needs Persistent Memory
That’s when I added the 🤖 (robot) tags – and everything clicked:
// [🤖 confidence-low: auth/logic] Complex business logic, needs more context
// [🤖 pattern-detected: Observer pattern with custom modifications]
// [🤖 refactor-suggestion: Consider extracting strategy pattern here]
// [🤖 agent:security-scanner: vulnerability-check-passed: 2025-05-22]
// [🤖 agent:performance-analyzer: possible-n+1-query: investigate UserRepository.findAll()]These tags let AI build understanding across sessions. It’s like giving AI a notebook that doesn’t disappear when you close the chat.
But then I realized something even bigger: multiple AI agents could collaborate through these tags.
Imagine:
- A security-focused AI leaves notes about potential vulnerabilities
- A performance AI marks possible bottlenecks
- A refactoring AI suggests patterns
- A documentation AI identifies missing explanations
- Each agent builds on the others’ insights
It’s not just memory – it’s asynchronous AI collaboration.
Why This Matters
What started as a simple codegen utility revealed a fundamental truth: all our tools need to speak the same language about code structure.
Whether it’s:
- Plop generating components
- Spring Boot CLI scaffolding controllers
- AI assistants refactoring code
- Linters checking standards
- Humans understanding intent
They all need to understand what’s structural (🧩), what’s human context (📌), and what’s machine memory (🤖).
The Decision to Open Source
I could have kept Robokeytags as an internal Robokeys tool. But the more I used it, the more I realized this problem is universal. Every developer using code generation or AI faces these same challenges.
The 🤖 tags especially felt too important to keep private. They could fundamentally change how AI assistants work with code – from stateless helpers to tools with real memory and understanding.
But more than that, they enable something we’ve never had before: AI agents that can work together on your codebase, leaving notes and building shared understanding over time.
One agent’s uncertainty becomes another agent’s investigation. One agent’s pattern detection becomes another’s refactoring opportunity. It’s like having a persistent AI team discussion embedded in your code.
What’s Next
Automotan Tags v1.0 is now open source. It’s battle-tested from months of internal use at Robokeys. But I believe the community will take it places I never imagined.
Some possibilities I’m excited about:
- IDE plugins that visualize the puzzle structure
- AI assistants that remember everything between sessions
- Linters that understand tool boundaries
- Code review tools that highlight structural changes
Join the Journey
If you’re frustrated by:
- Code generators that don’t know where to insert
- AI that forgets everything between chats
- The chaos of multiple tool conventions
- Lost context in your codebase
Then Robokeytags might be your answer too.
Check out the spec: github.com/robokeys/robokeytags
Or read more about how it solves the AI memory problem: robokeys.tech/robokeytags
This started as a simple internal tool. With your help, it could become the standard for how all our tools understand code.
What code generation or AI collaboration problems are you facing? I’d love to hear if Automotan Tags might help solve them.