Sometimes the biggest productivity boost is just not losing your work.
The Frustration
You ask an AI assistant to scaffold a new endpoint or component. It does a great job. Weeks later, you ask it for a small change, and it overwrites your carefully tuned code with generic boilerplate.
I’ve seen it happen often enough that I now back up my code every time I ask an AI for help. On the backend, it happens in Spring Boot controllers. On the frontend, it’s SvelteKit components. In both cases, I’ve lost custom logic, styling, or validation. It’s not really happening because the AI is wrong, but because it doesn’t know what parts of the file it shouldn’t touch.
The Real Problem
AI coding tools are incredibly powerful, but we’re still working with tools that don’t understand ownership. There’s no shared language between humans and machines about which parts of a file are editable, protected, or generated. And that’s a problem, especially as we move toward more AI-assisted development.
The Solution I Needed: Robokeytags
To solve this, I created Robokeytags: a simple comment-based tagging system that tells tools what’s safe to touch and what isn’t.
It uses three emoji markers:
🧩 Puzzle — Structural metadata (regions, boundaries, edit rules)
📌 Pin — Human-readable documentation (context, warnings, TODOs)
🤖 Robot — AI’s persistent memory (patterns, confidence, analysis)
The File Info Block
One of the most useful parts of Robokeytags isn’t even about regions of code, it’s the file header.
At the top of a file, you can include a structured [🧩 File Info] block. This acts like metadata for humans and tools:
// [🧩 File Info]
// path: src/routes/user/+page.svelte
// description: User dashboard view
// created: 2025-05-21
// editable: yes
// puzzlepins_version: 1.0
// [📌 Note: This file contains sensitive UI interactions.]
// [/🧩 File Info]
It works like a file-level README. Tools can use it for indexing, and humans can use it to remember what the file does and why it matters.
How It Works (In Real Code)
Here’s a Spring Boot example:
@RestController
@RequestMapping("/api/users")
public class UserController {
// [🧩 Region: NonEditable: crud/basic]
@GetMapping
public ResponseEntity<List> getAllUsers() {
return ResponseEntity.ok(userService.findAll());
}
// [/ 🧩 Region: NonEditable: crud/basic]
// [🧩 Region: Editable: custom/logic]
@PostMapping("/verify")
public ResponseEntity<?> verifyUser(...) {
// Custom logic the AI should never touch
return runComplexVerification();
}
// [/ 🧩 Region: Editable: custom/logic]
}
And here’s a snippet from a SvelteKit component:
<!-- [🧩 Region: NonEditable: component/props] -->
<script>
export let title;
export let items = [];
</script>
<!-- [/🧩 Region: NonEditable: component/props] -->
<!-- [🧩 Region: Editable: component/state] -->
<!-- [🤖 pattern-detected: Local state management] -->
<script>
let selectedId = null;
function toggle() { ... }
</script>
<!-- [/🧩 Region: Editable: component/state] -->
It’s just structured comments. But those comments make all the difference.
The Game Changer: AI Memory
The real breakthrough is the 🤖 Robot tags. They solve AI’s biggest weakness: memory. Its a common issue, when the task is simply too big for the AI. You give it a broad instruction like “Add validation to the user form” … and the AI forgets what was already there, or misses key dependencies.
AIs can use the 🤖 Robot tags to build persistent understanding, essentially giving them a way to extend their memory by tagging and revisiting code.
// [🤖 confidence-low: fieldValidation]
// This validation is a guess and might need human review
// [🤖 pattern-detected: service-delegation]
// Detected service pattern; may want to extract interface
// [🤖 agent:security: reviewed: 2025-05-22]
// No SQL injection risks foundThis lets AI tools build knowledge over time. Even better, multiple AI agents can collaborate through these tags, each adding their insights.
Why I’m Using It Everywhere
This system has already transformed how I work with AI. It’s helped me:
- Preserve business logic across AI sessions
- Enable multiple AI agents to collaborate
- Review code with full context
- Build institutional knowledge that persists
And when I revisit older code, those tags tell the complete story: what’s structural, what’s important to humans, and what AI has learned.
Want to Try It?
Automotan Tags is open source and designed to be language-agnostic. The full spec is at:
🔗 https://robokeys.tech/a-practical-framework-for-human-ai-code-collaboration/
Or dive straight into the repo:
🔗 https://github.com/robokeys/robokeytags
If you’ve ever lost good work to a well-meaning AI then Automotan Tags is for you.
More thoughts like this, and deeper dives into human-AI collaboration, are coming soon. If you’re working with AI tools or building dev workflows that use automation, I’d love to connect.
This is just the start of something bigger I’m building.