The Problem Nobody Talks About
We’re all running code agents. Claude Code, Codex, Cursor Agent, Gemini CLI — the options are endless. But there’s a pattern repeating across every team: the agent is powerful, but the workflow around it is a mess.
You copy and paste prompts. You babysit every session. There’s no way to know what an agent did yesterday. And when the agent generates code, it skips specs, ignores tests, and takes the shortest possible shortcut.
It’s not a model problem. It’s an infrastructure problem. You’re missing the layer between “I have an agent” and “I have an agent that works like a real team member.”
This week, two repositories that tackle exactly this problem exploded on GitHub Trending. And what’s interesting is they solve the two halves of the same gap.
Multica: Your Agents on the Board, Like Team Members
Repo: github.com/multica-ai/multica
Stars: ~15K | Forks: ~1.8K | License: Apache-2.0 | Language: TypeScript + Go
Multica is an open-source managed agent platform. The proposition is straightforward: instead of interacting with your agents via terminal one by one, you turn them into team members with presence on a project board.
How It Works
You install the CLI, spin up the daemon, and Multica automatically detects which agents you have available in your PATH — Claude Code, Codex, OpenClaw, OpenCode, Hermes, Gemini, Pi, or Cursor Agent.
# Installation
curl -fsSL https://raw.githubusercontent.com/multica-ai/multica/main/scripts/install.sh | bash
# Setup and start
multica setup
Once connected, you create agents from the web interface. Each agent has a name, profile, and appears on the board like any other team member. You assign it an issue → the agent takes it, writes code, reports blockers, updates the status. No intervention.
The Architecture
┌──────────────┐ ┌──────────────┐ ┌──────────────────┐
│ Next.js │────→│ Go Backend │────→│ PostgreSQL │
│ Frontend │←────│ (Chi + WS) │←────│ (pgvector) │
└──────────────┘ └──────┬───────┘ └──────────────────┘
│
┌──────┴───────┐
│ Agent Daemon │
│ (your local │
│ machine or │
│ cloud) │
└──────────────┘
The daemon runs on your local machine and connects to the backend via WebSocket. When an agent receives a task, the daemon creates an isolated environment, executes the agent, and reports the results. There’s also an option for Multica Cloud if you don’t want to self-host.
What Sets It Apart
Composite Skills: each solution an agent finds becomes a reusable skill for the whole team. Deployments, migrations, code reviews — skills accumulate over time. The agent that solved the CORS problem last week “remembers” the solution for next time.
Multi-workspace: isolation at the workspace level. Each workspace has its own agents, issues, and configurations. Think of it as having separate teams with their own specialized agents.
Vendor-neutral: you’re not locked into any provider. You can mix Claude Code for complex tasks, Codex for massive refactors, and OpenCode for anything else — all coordinated from the same board.
agent-skills: The Discipline of a Senior Engineer, Packaged in Markdown
Repo: github.com/addyosmani/agent-skills
Stars: ~16K | Forks: ~2.1K | License: MIT | Author: Addy Osmani (Google)
If Multica solves the “where and how agents coordinate,” agent-skills solves the “what discipline they follow when working.”
Addy Osmani — Engineering Manager at Google Chrome, author of classic JavaScript books — packaged Google’s production engineering practices into 20 structured skills that any code agent can follow.
The Problem It Tackles
Code agents take the shortest path. You ask for a feature and it gives it to you without specs, without tests, without security review. It works in the moment, but it’s the kind of code a senior engineer would reject in code review.
agent-skills gives the agent a structured process for each phase of development:
| Phase | Skills | What They Enforce |
|---|---|---|
| Define | idea-refine, spec-driven-development | Requirements before code |
| Plan | planning-and-task-breakdown | Breaking down into verifiable chunks |
| Build | incremental-implementation, context-engineering, frontend-ui-engineering | Vertical slices, correct context |
| Verify | test-driven-development, debugging-and-error-recovery | Testing that it works with real tests |
| Review | code-review-and-quality, security-and-hardening | Quality gates before merge |
| Ship | git-workflow-and-versioning, ci-cd-and-automation, shipping-and-launch | Safe and documented releases |
How to Use It
With Claude Code, the installation is straightforward:
# Install as a plugin
claude plugin add agent-skills
# Or clone and reference
git clone https://github.com/addyosmani/agent-skills.git
Once installed, you have slash commands:
/spec → Start spec-driven development
/plan → Break down work into tasks
/build → Implement incrementally
/test → TDD workflow
/review → Trigger code review
/ship → Pre-launch checklist
For Cursor, you copy the SKILL.md files to .cursor/rules/. For Windsurf, you add them to the rules configuration. For Copilot, they go as agent personas. And since each skill is simply a Markdown file, it works with any agent that accepts system prompts.
What Makes These Skills Different
They’re not generic prompts like “write good tests.” Each skill includes:
Rationalization-Blocking Tables. These are the excuses agents use to skip important steps, with factual counterarguments. When your agent thinks “this is simple, it doesn’t need a spec,” the skill intercepts it with reasoning for why it does.
Verification Gates. Checkpoints at each step of the process. The agent doesn’t move to the next phase until the current one is verified.
Red Flags. Observable signals that the skill is being violated. Useful both for the agent in self-monitoring mode and for you when reviewing the output.
The inspiration comes straight from Google’s engineering culture — Hyrum’s Law for API design, the Beyonce Rule for testing, the test pyramid (80/15/5).
Included Agent Personas
Beyond the skills, the repo includes reusable personas you can invoke:
- code-reviewer — reviews PRs with senior engineer standards
- test-engineer — analyzes test coverage and quality
- security-auditor — audits endpoints and detects vulnerabilities
The Real Story: Two Layers of the Same Emerging Stack
What’s interesting about Multica and agent-skills trending the same week is what it says about where the industry is heading.
The development stack with agents is stratifying:
- Model Layer — Claude, GPT, Gemini, etc. (solved)
- Agent Layer — Claude Code, Codex, Cursor Agent (solved)
- Coordination Layer — Multica, similar tools (emerging now)
- Discipline Layer — agent-skills, similar tools (emerging now)
Layers 1 and 2 are already mature. Layers 3 and 4 are exactly what was missing to move from “a dev with an agent” to “a team where agents are productive coworkers.”
Multica handles the where and when agents work. agent-skills handles the how and what quality standard. They’re complementary by design, even though they weren’t created together.
How to Get Started
If you work solo or in a small team: start with agent-skills. It’s zero infrastructure — you install the plugin or copy the Markdown, and your agent immediately produces code with more discipline. The impact is instant.
If you’re coordinating multiple agents or have a team: Multica makes more sense. The investment in setup (self-hosted or cloud) is justified when you need several agents working in parallel with centralized visibility.
If you want both: you install Multica for coordination, and agent-skills get loaded into each individual agent. Multica’s skills (which accumulate) and Osmani’s agent-skills (which define the process) are complementary.
Links
- Multica: GitHub - multica-ai/multica: The open-source managed agents platform. Turn coding agents into real teammates — assign tasks, track progress, compound skills. · GitHub
- agent-skills: GitHub - addyosmani/agent-skills: Production-grade engineering skills for AI coding agents. · GitHub
- agent-skills Documentation: agent-skills/docs/getting-started.md at 9534f44c5448086fcc0046f9d83752c654c81930 · addyosmani/agent-skills · GitHub
Are you already using some layer of management or discipline over your code agents? Or are you still in copy-paste prompt mode? Let us know in the comments 