I manage 51 active project repositories. My team size is 1.

That's not a flex. It's an infrastructure problem I had to solve. I run an experiential tech company that builds software for MSPs, legal tech companies, and marketing tech companies. I also maintain our own products. At some point the number of codebases crossed a threshold where traditional project management -- Jira boards, weekly standups, careful context switching -- stopped working.

The usual answer is "hire more people." Instead, I built an operating system that makes AI agents do most of the work that used to require a team.

Here's what that actually looks like.

The Operating System

Everything starts with documentation. Not the kind that sits in a Confluence page nobody reads. The kind that AI tools read automatically every time they start a session.

My internal OS is a single git repository: 709 markdown files, 278,000+ lines. It covers company policies, engineering standards, security playbooks, compliance frameworks, postmortem templates, and architecture decision records. Every department has a handbook. Every process has a checklist.

This isn't overhead. This IS the infrastructure. When I open Claude Code on any of those 51 projects, it reads the CLAUDE.md file and immediately knows my coding standards, my deployment patterns, my security requirements, and how I like things done. I don't re-explain anything. The documentation is the onboarding.

263 Skills

Skills are reusable instruction sets -- like SOPs for AI agents. Instead of explaining what I want each time, I run a command.

/feature-plan generates a complete feature specification with architecture decisions, component breakdown, and implementation steps. A different skill, /planning-qa, scores that spec on a 100-point rubric. Anything below 90 gets reworked. The generator and the checker are separate -- the AI doesn't grade its own homework.

/gcam commits all changes (excluding .env files) and pushes to main. /code-review spins up 6 specialized agents -- security sentinel, performance oracle, architecture reviewer, pattern recognition specialist -- that review code from different angles before any PR gets created.

I have 263 of these skills. They cover feature planning, code review, deployment, security audits, content creation, SEO optimization, email campaigns, and more. Every skill is synced across Claude Code, Cursor, and Codex using a tool called ai-rules-sync. Every AI tool I touch follows the same standards and has access to the same workflows.

Building these took months. Using them takes seconds.

A Typical Day

Morning: I open my prioritized task tracker. Claude Code reads the context and proposes a work plan.

Building: I pick a project, run /feature-plan to generate the spec, run /planning-qa to score it. If it passes, I start implementation. Claude Code reads the project's CLAUDE.md, follows the coding standards, and builds with awareness of the architecture.

Reviewing: Before every PR, the multi-agent code review runs. Six agents check security, performance, architecture, patterns, testing, and style. I focus my review on business logic and edge cases -- the stuff AI still misses.

Shipping: Deployment checklists are encoded in skills. Pre-commit hooks catch secrets via gitleaks. The deployment skill knows the pattern: dev branch goes to staging, main goes to production.

Learning: When something breaks, a postmortem gets written. Not a blame document -- a structured learning that feeds back into the skills and checklists. I have 15 postmortem reports so far. Each one made the system smarter.

What Doesn't Work

I'm not going to pretend this is seamless.

Running too many sessions at once. I've tried 4-5 Claude Code sessions in parallel. The context switching is brutal. You're not coding anymore -- you're managing, and you didn't sign up for that. Two to three concurrent sessions is my practical limit.

Trusting agent output without review. AI-generated code looks professional. It compiles. It often passes basic tests. And then it has a subtle bug that only shows up in production. The "plausible but wrong" trap is real. Every agent output gets reviewed, period.

Skipping documentation. There was a phase where I thought I could move fast and document later. That's the fastest way to make your AI agents useless. They're only as good as the context they can read. Stale docs produce stale output.

Expecting AI to understand business context. AI is great at "how." It's bad at "why." It'll build exactly what you ask for without questioning whether it should exist. The decision-making is still mine.

The Numbers

• 51 active project repositories
• 263 Claude skills
• 709 documentation files
• 278,000+ lines of documentation
• 30 ISO 42001 compliance documents (built in days, not months)
• 14 security incident response playbooks
• 15 postmortem reports
• 7 engineering checklists

All managed by one person with AI agents.

Why I'm Sharing This

I build software for MSPs, legal tech companies, and marketing tech companies. The AI infrastructure I use internally is the same system I deploy for clients.

When a client hires us, they don't start from zero. They get the 100-hour head start -- everything I figured out through trial and error about where skills should live, how to sync standards across tools, how to set up code review agents, how to structure a devkit. We customize it for their team, their stack, their workflows.

Most companies I talk to are stuck at what I call Level 1: copying and pasting into ChatGPT and accepting whatever comes back. They know AI can do more but don't know how to get there.

The gap isn't knowledge. It's infrastructure.

If you're curious where your team stands, start with the maturity assessment and map the biggest opportunities in your workflow, standards, and governance setup before you chase more tooling.

I run Namos Labs, a human-first AI product studio focused on systems, software, and practical operating models for teams adopting AI.