I've been frustrated for a long time.
Every "awesome Claude prompts" repo I found looked like this:
"Act as a senior software engineer. Be helpful, thorough,
and professional. Consider edge cases."
That's not a skill. That's a costume.
Real expertise has frameworks. Named responsibilities.
Actual formulas. Code that runs. Constraints that prevent
the model from giving you the easy wrong answer.
So I spent 6 months building what I actually wanted.AgentOS 2.0 — 135 production-grade Claude Skills. This article explains exactly what's inside and why it's
different from every other prompt collection on GitHub.
The Problem With Every Other Prompt Repo #
Most prompt repositories fall into one of three traps:Trap 1: The costume prompt``` "You are an expert financial analyst. Help the user with their finance questions."
Zero frameworks. Zero formulas. Zero depth.**Trap 2: The instruction dump**```
"When answering, always:
- Be professional
- Consider multiple angles
- Cite sources
- Format your response clearly"
This is just asking Claude to be Claude. It changes nothing.Trap 3: The persona prompt``` "You are Alex, a no-nonsense McKinsey consultant with 20 years of experience..."
Roleplay, not expertise. The model doesn't suddenly
know DCF models because you named it Alex.**What actually works:** Named sub-agents with
distinct responsibilities, actual domain formulas
in code, and explicit forbidden behaviors that
prevent hallucination in critical areas.
Here's what that looks like in practice.
## What "Production-Grade" Actually Looks Like
### FinanceOracle — The Apex Skill
This is the most complete skill in the repo.
Here's a fraction of what's inside:**12 Sub-Agents:**
-
`OptionsDesk`
— derivatives pricing and structuring -
`MacroStrategist`
— macro regime analysis -
`HedgeFundArchitect`
— strategy design -
`FamilyOfficeCIO`
— multi-generational allocation -
`TaxOptimizer`
— harvest and structure optimization -
`DerivativesStructurer`
— exotic product design*(+ 6 more)*
**Actual runnable Python:**
``` python
def black_scholes(S, K, T, r, sigma, option_type='call'):
d1 = (np.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
if option_type == 'call':
price = S * norm.cdf(d1) - K * np.exp(-r*T) * norm.cdf(d2)
delta = norm.cdf(d1)
else:
price = K * np.exp(-r*T) * norm.cdf(-d2) - S * norm.cdf(-d1)
delta = -norm.cdf(-d1)
gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
vega = S * norm.pdf(d1) * np.sqrt(T) / 100
theta = (-(S * norm.pdf(d1) * sigma) / (2 * np.sqrt(T))
- r * K * np.exp(-r*T) * norm.cdf(d2)) / 365
return {"price": price, "delta": delta,
"gamma": gamma, "vega": vega, "theta": theta}
Black-Litterman portfolio construction:
def black_litterman(Sigma, market_weights, views_P,
views_Q, views_omega, tau=0.05, delta=2.5):
pi = delta * Sigma @ market_weights
M_inv = np.linalg.inv(
np.linalg.inv(tau * Sigma) +
views_P.T @ np.linalg.inv(views_omega) @ views_P
)
mu_bl = M_inv @ (
np.linalg.inv(tau * Sigma) @ pi +
views_P.T @ np.linalg.inv(views_omega) @ views_Q
)
return {"expected_returns": mu_bl}
This isn't pseudocode. This runs.
OKREngine — Catches Failures Before They Kill Your Quarter
I've watched two startups waste entire quarters on
broken OKRs. This skill exists because of that.
The objective quality scorer:``` php def score_okr(objective: str, key_results: list[dict]) -> dict: obj_score = 0 obj_score += 3 if len(objective) < 100 else 0 obj_score += 3 if not objective.lower().startswith("improve") else 0 obj_score += 4 if any(w in objective.lower() for w in ["best", "lead", "#1", "transform", "redefine"]) else 0
kr_scores = []
for kr in key_results:
kr_score = 0
kr_score += 3 if kr.get("metric") else 0
kr_score += 3 if kr.get("baseline") is not None else 0
kr_score += 4 if kr.get("target") is not None else 0
kr_scores.append({
"kr": kr["text"][:60],
"score": kr_score,
"grade": "Good" if kr_score >= 8 else "Needs work"
})
return {
"objective_score": f"{obj_score}/10",
"key_results": kr_scores,
"recommendation": "Strong OKR" if obj_score >= 8 else "Needs revision"
}
The skill also catches the**12 most common OKR failure modes** — including sandbagging, health metrics disguised as OKRs, and the single most destructive mistake: tying OKR scores to bonuses.
### VentureIntelligence — Term Sheet Red Flag Detector
``` php
def score_term_sheet(terms: dict) -> dict:
red_flags = []
if terms.get("liq_pref_multiple", 1) > 1:
red_flags.append(
f"Liquidation preference {terms['liq_pref_multiple']}x — above 1x is punishing"
)
if terms.get("participating_preferred", False):
red_flags.append(
"Participating preferred — VCs get paid twice in exits below threshold"
)
if terms.get("anti_dilution") == "full_ratchet":
red_flags.append(
"Full ratchet anti-dilution — catastrophic in a down round"
)
if terms.get("board_seats_investor", 0) > terms.get("board_seats_founder", 0):
red_flags.append(
"Investor has majority board control — you can be fired from your company"
)
score = 10 - (len(red_flags) * 3)
return {
"score": max(0, score),
"grade": "Sign it" if score >= 8 else "Negotiate" if score >= 5 else "Get a lawyer NOW",
"red_flags": red_flags
}
12 sub-agents including TermSheetDecoder
, ValuationNegotiator
, ChampionDeveloper
, and BoardRelationshipManager
.
CrisisIntelligence — War Room OS
Every company will face a crisis. Almost none prepare.
def classify_crisis(crisis: dict) -> dict:
severity_score = 0
if crisis["customer_impact_pct"] >= 0.5: severity_score += 30
if crisis["revenue_at_risk"] >= 1_000_000: severity_score += 20
coverage = {"none": 0, "local": 5, "national": 15, "viral": 30}
severity_score += coverage.get(crisis["media_coverage"], 0)
if crisis["regulatory_involvement"]: severity_score += 15
if crisis["legal_liability"]: severity_score += 15
if severity_score >= 70:
level = "CRITICAL (P0)"
action = "CEO leads. War room activated NOW."
elif severity_score >= 40:
level = "HIGH (P1)"
action = "VP-level lead. External comms needed."
else:
level = "MEDIUM (P2)"
action = "Director-level. Monitor externally."
return {
"level": level,
"immediate_action": action,
"time_to_first_response": "1 hour" if severity_score >= 70 else "4 hours"
}
The 5Rs framework (Recognize → Respond → Responsible → Remediate → Restore) is built into every communication template.
How It Works (60-Second Setup) #
Claude.ai Projects: Claude Code:cat finance-oracle/SKILL.md >> .claude/CLAUDE.mdClaude API:``` python
import anthropic
with open("startup-cto/SKILL.md", "r") as f: skill = f.read()
client = anthropic.Anthropic() response = client.messages.create( model="claude-sonnet-4-6", max_tokens=4096, system=skill, messages=[{"role": "user", "content": "Audit our tech stack decision"}] )
That's it. Claude is now that specialist.
## The Full 135-Skill Index**🚀 Startup & Team Management (11)**`startup-cto`
`team-performance-os`
`startup-hiring-machine`
`culture-architect`
`remote-team-commander`
`okr-engine`
`startup-finance-controller`
`venture-intelligence`
`startup-legal-shield`
`talent-management-os`
`talent-brand-builder`**🏆 Apex Legendary (4)**` finance-oracle`
`claude-mythos`
`ceo-war-room`
`founder-to-ceo`**🤖 AI & Engineering (14)**` rag-architect`
`mlops-engineer`
`system-architect`
`senior-dev`
`ai-red-teamer`
`voice-agent-builder`
`knowledge-graph-builder`
`incident-commander`
`mcp-builder`
`agentic-workflow-builder`
`api-integrator`
`realtime-data-agent`
`agent-smith`
`prompt-engineer`**📊 Data & Analytics (10)**` data-scientist-pro`
`sql-analyzer`
`data-pipeline-pro`
`business-intelligence-pro`
`timeseries-oracle`
`quant-trader`
`synthetic-data-generator`
`arxiv-researcher`
`abtest-scientist`
`data-governance-agent`**💹 Finance (9)**` finance-oracle`
`financial-model-builder`
`cfo-intelligence`
`portfolio-optimizer`
`quant-researcher`
`saas-metrics-analyst`
`insurance-actuary`
`ma-dealmaker`
`risk-sentinel`**🏢 Operations & Business (20)**
`ceo-war-room`
`founder-to-ceo`
`go-to-market-commander`
`enterprise-sales-os`
`sales-enablement-os`
`board-deck-builder`
`crisis-intelligence`
`partnership-intelligence`
`pricing-strategist`
`project-command`
`marketing-os`
`supply-chain-oracle`
*(+ 8 more)*
**👤 Product & Customer (11)**`product-roadmap-os`
`sprint-master`
`engineering-manager`
`ai-product-manager`
`user-research-os`
`customer-interview-analyst`
`product-analytics-os`
`network-effects-analyst`
`marketplace-strategist`
`performance-marketing-os`
`churn-analyst`**🛠 Developer Tools (19)**
`developer-experience-os`
`api-design-architect`
`data-warehouse-architect`
`cloud-cost-optimizer`
`design-system-architect`
`technical-pm`
`code-reviewer`
`load-tester`
`code-migrator`
`webapp-tester`
*(+ 9 more)*
**🌐 Specialized Domains (12)**
`healthcare-analytics`
`web3-developer`
`climate-tech-analyst`
`biotech-analyst`
`cybersecurity-analyst`
`real-estate-intelligence`
`legal-eagle`
`patent-analyst`
`esg-compass`
*(+ 3 more)*
## What Makes This Different From Every Other Repo
| Feature | Generic repos | AgentOS 2.0 |
|---|---|---|
| Sub-agents | ❌ | ✅ 10-12 per skill |
| Actual formulas | ❌ | ✅ Black-Scholes, DCF, MEDDPICC |
| Runnable code | ❌ | ✅ Python, TypeScript, Go, Shell |
| Forbidden behaviors | ❌ | ✅ Every skill |
| Benchmark data | ❌ | ✅ Industry standards built in |
| Total skills | ~10-20 | 135+ |
## Try It Right Now
The fastest way to understand the depth is to try one.
I recommend starting with **okr-engine** or**— they're the most complete and immediately useful regardless of what you're building.**`startup-cto`
Paste the SKILL.md into Claude Projects. Ask it to review your current OKRs or tech stack. You'll see the difference immediately.
GitHub link in the comments.**What skill would you build your work around?** Drop it below — I read every comment and I'm actively building more.
*MIT License. Free forever. Star it if it's useful — helps others find it.*source & further reading
dev.to — original article
Reviewing Patrick Collison's Ask for an LLM Workflow Tool
5 AI-Entertainment Hacks That Hit 100+ Upvotes — and What I Learned From Each
Prefix caching at scale: when it saves you 80% of prefill cost, and the eviction policies that quietly turn it into 5%