Human-AI Collaboration, Inside Git Here’s the shift: instead of switching to ChatGPT and copy-pasting code, using Cursor, Windsurf or Claude CLI, you work inside GitHub. The AI is already there. Say you write an idea.md file:

Idea: Internal tool for CSV upload & charts

Allow team members to upload CSV files, view them as interactive tables, and generate simple charts. Bonus: export to PDF. Push it. Boom. The project-seeder agent picks it up. It scaffolds a repo using a full-stack framework (like Next.js + React + Chart.js), sets up file upload endpoints, auto-generates UI components, and pushes working code. It even opens issues like: “Add CSV validation rules” “Improve mobile layout” “Set up PDF export”

You didn’t chat with anyone. You just wrote a spec and committed it. That was the prompt. And if you didn’t write a spec? No problem - there’s an agent for that too. Architecture planning, backlog creation, even task breakdowns. The system can generate those as a starting point. You just give feedback.

How It Works Each agent is a version-controlled YAML + Markdown file. You define triggers: on: pull_request, or mentions: “@code-reviewer”. When triggered, an agent runs inside GitHub Actions. It can:

Read files in the repo

  1. Analyze diffs or CI logs

  2. Post comments or open issues

  3. Even create commits

  4. Draft specs and architecture docs

  5. Generate other agents by extending or specializing capabilities

  6. Create new workflows to coordinate tasks across teams of agents Agents have memory: they evolve with the repo. You update their prompts the same way you update code.

A Simple Loop You open a PR. @code-reviewer runs. It posts feedback. You comment @fixer-agent please handle this. It pushes a patch. Need a new feature? Just open an issue with a one-line description. An agent picks it up and starts working. The only thing left for you to do? Approve PRs. Or comment what you’d like changed. The repo changes → agents respond → repo updates again. It’s not just code anymore. It’s a conversation, happening through commits and comments.

Agents Can Inherit - and Collaborate a5c agents aren’t just independent scripts. They’re part of a system that’s built to scale. 🧬 Inheritance Agents can inherit from other agents, just like classes in code or layers in Docker. This means you can define a base agent - say, a general code-reviewer-and extend it to make security-reviewer, frontend-reviewer, or performance-reviewer, each adding its own special focus. You don’t start from scratch. You build on intelligence that’s already there. 🧑‍🤝‍🧑 Agent Teams Agents don’t just inherit - they collaborate. A single agent can recruit others. For example, the project-seeder might create a new repo, then trigger the developer-agent to implement features, the doc-agent to write documentation, and the qa-agent to create tests. These agents coordinate with each other, share context, and progress tasks in parallel. What used to take a sprint? Now happens in minutes. This isn’t prompt engineering. It’s AI-led teamwork inside your repo.

The End of Prompt Silos Prompts today are fragmented across personal tools and individual workflows. In most companies, people experiment alone - tweaking prompts in their private notebooks, terminals, or chat windows. If they discover something that works, the best-case scenario is they screenshot it or copy-paste it into Slack. There’s no shared history. No learning over time. No versioning. No way to evolve prompts together or trace why something worked. a5c changes that. Because agents and their prompts live in Git, everything is versioned, shared, and visible. Teams can improve prompts like they improve code. If someone finds a better way to write a review prompt, they commit it. Everyone benefits. Prompt engineering becomes a team sport. Async. Documented. Scalable.

Why This Matters Coding used to be about writing everything by hand. But now? The valuable skill is orchestration: defining what should happen and letting intelligent systems take it from there. a5c lets your repo become an interface for that. No dashboards. No switching tools. Just Git. Smarter.

Push code. Get feedback. Write specs. Or let the repo write them. Label issues. Watch them get done. Your repo isn’t static anymore. It’s alive.