Embedded Files
# Unified Skills and AI Harness Repository: The Foundation Without Which Your Team Drowns in Chaos
## The Problem: Skills Are Scattered, Context Gets Lost
Here's what AI adoption in a company typically looks like after 3-6 months:
- One developer has a `.claude/` directory in their project with three skills
- Another has an `agents.md` in the root, written in a hurry
- A third has nothing at all — they just prompt the chat from scratch every time
- The team lead has a set of MCP servers configured locally and never showed anyone
- DevOps has deployment scripts that the agent calls, but they're undocumented
- The analyst has Excel macros they "automated with AI," but nobody knows how
Everyone is cooking in their own pot. Skills aren't reused. Context isn't shared between units. When someone leaves — their knowledge leaves with them. When a new person joins — they start from scratch.
This is not "agentic development." It's **chaos** disguised as innovation.
---
## Why This Happens
Three reasons:
**1. There's no single entry point.**
Everyone configures the agent for themselves, in their own project, in their own directory. There's no shared place with vetted skills, working MCP configs, and baseline instructions.
**2. There's no culture of reuse.**
When a developer writes a skill for their own task, they don't think: "Could this skill be useful to someone else?" They think: "I need to solve this task right now." And the skill stays in their project, invisible to everyone else.
**3. There's no evolution process.**
Even if a skill is good — who maintains it? Who updates it when the model changes, when new features appear, when the codebase evolves? Nobody. The skill dies within a month.
---
## The Solution: A Unified AI Infrastructure Repository
You need **one repository** that serves as the single entry point for the entire team. Not a "metarepo with instructions for humans" (hello, Raiffeisen). A **living repository with executable code** that the agent uses directly.
### What's Inside
```
ai-harness/
├── skills/ # All team skills
│ ├── code-review/
│ │ ├── skill.md # Agent instruction
│ │ ├── tests/ # Skill tests (Red Team)
│ │ └── examples/ # Usage examples
│ ├── migration/
│ │ ├── skill.md
│ │ ├── tests/
│ │ └── examples/
│ ├── debugging/
│ ├── deployment/
│ ├── documentation/
│ └── ...
│
├── mcp-servers/ # MCP server configurations
│ ├── browser/ # Playwright / Agent Browser
│ │ ├── config.json
│ │ └── README.md
│ ├── database/ # Database connection
│ ├── ci-cd/ # GitLab CI / GitHub Actions
│ ├── jira/ # Jira integration
│ └── ...
│
├── agents/ # Baseline agents.md for different roles
│ ├── backend-developer.md
│ ├── frontend-developer.md
│ ├── devops.md
│ ├── qa.md
│ ├── analyst.md
│ └── ...
│
├── prompts/ # System prompts and templates
│ ├── code-generation.md
│ ├── code-review.md
│ ├── architecture.md
│ ├── migration.md
│ └── ...
│
├── rules/ # Project rules
│ ├── coding-standards.md
│ ├── architecture-rules.md
│ ├── security-rules.md
│ └── ...
│
├── memory/ # memory.md templates
│ ├── task-memory.md
│ ├── project-memory.md
│ └── ...
│
├── metrics/ # Logging and analysis scripts
│ ├── session-analyzer.py
│ ├── cost-quality-report.py
│ └── ...
│
└── README.md # How to use, how to add skills
```
### Principles
**1. Executable, not documentation.**
Every skill is not a "human instruction on how to set up folders." It's **working code** that the agent calls directly. A `code-review` skill is not a README on "how to do reviews." It's a prompt + tests + examples that the agent uses for automated reviews.
**2. Verifiable.**
Every skill has **tests**. Not "write a service summary." Concrete test cases: "Give the agent this code, run the skill, verify that it found these 3 issues." If a skill doesn't pass tests — it doesn't get merged.
**3. Versioned.**
The repository is in Git. Every skill has a change history. When the model updates, when new features appear — skills are updated, and you can see who changed what, when, and why.
**4. Reusable.**
Any team member can take a skill from the repository and use it in their project. Not by manually copying. By connecting it as a dependency.
---
## How the Team Uses the Repository
### Scenario 1: New Developer Joins the Team
Before:
- A new person joins
- Spends a week setting up their environment
- Writes their own prompts from scratch
- Doesn't know which MCP servers are available
- Doesn't know the project rules
With the repository:
- A new person joins
- Clones `ai-harness`
- Connects `agents/backend-developer.md` to their project
- The agent immediately knows the rules, skills, and tools
- **Day 1 is productive**, not day 7
### Scenario 2: Developer Wrote a New Skill
Before:
- Developer wrote a skill in their project
- The skill works for them
- Nobody knows it exists
- A month later the developer leaves, the skill dies
With the repository:
- Developer wrote a skill
- Pushed it to `ai-harness/skills/`
- Wrote tests (Red Team via subagents)
- Made a PR, the team reviewed it
- The skill is available to the whole team
- **Knowledge is not lost**
### Scenario 3: Model Update
Before:
- A new model is released
- Each developer manually checks whether their prompts still work
- Some prompts break
- Each person fixes things at their own pace
- Chaos
With the repository:
- A new model is released
- Automated tests for all skills run automatically
- You can see which skills broke
- One person (or an agent) fixes them
- The team gets updated skills via PR
- **Centralized updates**
---
## Repository Evolution
The repository is not a static thing. It **evolves** with the team.
### Phase 1: Collection (1-2 weeks)
- Gather all existing skills, prompts, and MCP configs from all projects
- Classify: what's universal, what's project-specific
- Universal goes into the repository. Project-specific stays in the project
### Phase 2: Standardization (2-4 weeks)
- Write baseline `agents.md` for each role
- Create skill templates
- Set up MCP servers
- Write project rules
### Phase 3: Testing (ongoing)
- For every skill — tests via subagents without context
- If a skill doesn't pass tests — it doesn't get merged
- Regular test runs when models are updated
### Phase 4: Evolution (ongoing)
- The team adds new skills
- Updates existing ones
- Removes outdated ones
- Analyzes metrics: which skills are used, which aren't
---
## Why Raiffeisen Didn't Do This
In their article you can see:
- Skills are scattered across different repositories
- The metarepo is a wrapper with instructions for humans, not executable code
- No skill tests
- No versioning
- No evolution process
- "There was no common way to share them and pass context between units" (their quote)
Result: every unit cooks in its own pot. Skills aren't reused. When one unit finds a good solution — the others don't know about it.
This is not "agentic development." It's **16 people each playing with their own toys**.
---
## Practical Checklist: How to Create the Repository
**Week 1: Audit**
- [ ] Gather all existing skills from all projects
- [ ] Gather all MCP configs
- [ ] Gather all agents.md and prompts
- [ ] Classify: universal vs. project-specific
**Week 2: Structure**
- [ ] Create the `ai-harness` repository
- [ ] Define the directory structure
- [ ] Move in universal skills
- [ ] Set up MCP servers
**Week 3: Baseline Agents**
- [ ] Write `agents.md` for each role in the team
- [ ] Write baseline project rules
- [ ] Write memory.md templates
**Week 4: Testing**
- [ ] For every skill — tests via subagents
- [ ] Set up CI for running tests
- [ ] Document the process for adding skills
**Ongoing: Evolution**
- [ ] Weekly analysis: which skills are used
- [ ] Updates when new models are released
- [ ] Removal of outdated skills
- [ ] Onboarding new team members through the repository
---
## Repository Success Metrics
How to know the repository is working:
**1. New developer onboarding time.**
- Before: 5-7 days
- After: 1 day
**2. Skill reuse rate.**
- Before: 0% (everyone writes their own)
- After: 60-80% (most take from the repository)
**3. Number of duplicate skills.**
- Before: 5 code review skills across different projects
- After: 1 skill in the repository
**4. Update time when switching models.**
- Before: 2-3 weeks (everyone fixes on their own)
- After: 2-3 days (centralized)
**5. Percentage of skills with tests.**
- Before: 0%
- After: 100%
---
## Conclusion
A unified skills and AI harness repository is the **foundation** of agentic development. Without it:
- Skills are scattered and not reused
- Context is lost between units
- Knowledge leaves with people
- No evolution, no tests, no versioning
- The team drowns in chaos
With it:
- A single entry point for the entire team
- Skills are reused and evolve
- Knowledge is preserved in the repository
- Centralized updates when models change
- Onboarding in 1 day instead of a week
This is not "instructions for humans on how to set up folders." This is **executable code with tests** that the agent uses directly. This is not a README. This is **infrastructure**.
And this is what 90% of companies that are "adopting AI" are missing. They adopt tools. But they don't build infrastructure. And that's why they get chaos instead of transformation.
Page updated
Google Sites
Report abuse