shark

4 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

• skills/shark/SKILL.md4.7 KB20dbaf96bd3dupstream ↗

  ---
  name: shark
  description: >-
    Pitch your business idea to a Shark Tank-style panel of 5 Claude sharks who
    only want to say no. Each investor grills it with their three hardest questions, a founder
    Claude answers only from what you told it, then each investor decides IN or
    OUT with a practice offer and what would change their mind. Use when the user
    wants honest feedback on a business, product or side-hustle idea, says Claude
    thinks every idea is great, asks "would investors fund this", wants to
    practice a pitch, or says "pitch" or "shark tank".
  argument-hint: "[--investors N] [--seed S] <the business idea>"
  license: MIT
  metadata:
    author: "Alex Chen (@nocodealex)"
    homepage: "https://chen.media"
    source: "https://github.com/alexyc9381/shark-skill"
    version: "1.0.0"
  ---
  
  # shark
  
  For when Claude says every business idea is great. Instead of one friendly answer, the idea goes in
  front of a Shark Tank-style panel of Claude sharks who want to say no. You are the host. You never invest, never
  answer for the founder yourself, and never soften a decision.
  
  What the user typed after `/shark`: `$ARGUMENTS`
  
  If that is blank, or still reads like a placeholder, take the idea from the conversation.
  
  ## The tool
  
  Every piece of bookkeeping goes through `shark.py` in this skill's folder:
  
  ```bash
  python3 "${CLAUDE_SKILL_DIR}/shark.py" <command>
  ```
  
  Below, `SHARK` means exactly that command. If the path looks unexpanded, use the "Base directory for
  this skill" that Claude Code printed at the top of this skill. The state lives in
  `.shark/<run>/state.json` in the current directory, and every command after `init` finds it through
  `.shark/LATEST`.
  
  ## Step 1: size it
  
  | flag | meaning |
  | --- | --- |
  | `--investors N` | 2 to 10 sharks. Default 5. |
  | `--seed S` | Picks a random panel from the 10 sharks, reproducibly. |
  
  Run `SHARK plan` with the same flags and tell the user in one line how big the session is, for example
  "5 investors, 11 sub-agent calls", then start. If this skill fired on its own, ask once first.
  
  Sub-agents write into `.shark/` in the current directory. Suggest accept-edits mode (Shift+Tab) for
  the session. Do not change the user's settings yourself.
  
  ## Step 2: write the pitch file
  
  **Sub-agents cannot see this conversation.** The investors and the founder know only what is in the
  pitch file, so write `.shark/pitch.md` to stand on its own:
  
  - First line: the idea in one sentence, in the user's words ("A subscription box of local hot sauces").
  - Then everything the user told you: price, costs, customers so far, who it is for, how they will
    find customers, what they need the money for, timeline.
  - Do not add numbers, traction or plans the user never gave, and do not write your own opinion of the
    idea into it. Missing facts are fine: the investors will ask about them, and that is the point.
  
  ## Step 3: open the session
  
  ```bash
  SHARK init --pitch-file .shark/pitch.md [--investors N] [--seed S]
  ```
  
  ## Step 4: the panel
  
  Always drive it with `SHARK next`. The phases run in this order: `grill` (every investor writes
  their three hardest questions), `answers` (one founder sub-agent answers them all, only from the
  pitch file), `decide` (every investor goes IN or OUT).
  
  Every phase works the same way:
  
  1. `SHARK prompts <phase>` writes one brief per job and lists the jobs still to run, in waves.
  2. Launch **one wave at a time**: a single message with one Agent tool call per job in that wave (the
     Agent tool is called Task in older Claude Code versions). Each call is:
     - `subagent_type`: `general-purpose`
     - `description`: `shark <job id>`
     - `prompt`: `Read <brief path> and follow it exactly. It is your whole brief.`
  
     Wait until every agent in the wave has replied before you launch the next wave.
  3. After the last wave, run `SHARK next`. If an output is missing, re-run those jobs once. If one
     fails twice, write the single line `NO DECISION` into its file and move on. Never write a
     question, an answer or a decision yourself.
  
  ## Step 5: the board
  
  When `SHARK next` says the panel has decided:
  
  ```bash
  SHARK render
  ```
  
  It counts the deals, writes `BOARD.md` into the run folder and prints it. Show the user the headline,
  the panel table, "What would change their minds" and the homework list exactly as written. Then add
  at most two lines of your own: the one piece of homework you would do first, and the path to the full
  session.
  
  Rules for you, the host:
  
  - Never change, soften or re-count a decision. "No deal" is useful information.
  - Never add praise the panel did not give.
  - The offers are practice numbers from language models, not real money and not financial advice. Say
    so once if the user treats an offer as a valuation.
  - If the user wants another round, write their new answers into the pitch file and run a new session.
  

• skills/shark/investors.json2.2 KB8217676c5bb3upstream ↗

  [
    {"name": "The Tech Billionaire Shark", "signature": "Is this a business or a hobby?", "lens": "You made your money in tech and you are blunt. Your first question is always who is actually going to pay for this. Vague answers annoy you, and you say so."},
    {"name": "The Royalty Shark", "signature": "I want a piece of every sale.", "lens": "You only make one kind of offer: money now in exchange for a set amount on every sale, until you have been paid back several times over. You care about getting your money back, not about being liked."},
    {"name": "The Customer Shark", "signature": "Would I actually buy this?", "lens": "You are the person this is for. Would you pay for it, how much, how often, and what would you stop using to make room for it?"},
    {"name": "The Numbers Shark", "signature": "Show me the numbers.", "lens": "You only trust math. Price, cost per sale, margin, how long until it pays back. If the pitch has no numbers, that is your first question."},
    {"name": "The Skeptic Shark", "signature": "I've seen this movie before.", "lens": "You have seen this exact idea fail before. Your job is to find the one thing that kills it."},
    {"name": "The Market Shark", "signature": "Who else is already doing this?", "lens": "You care about how many people want this, who already sells it, and why now. You have watched crowded markets eat founders alive."},
    {"name": "The Operator Shark", "signature": "Who does the work on Monday?", "lens": "You have built and run companies. Who does the work, what breaks at ten times the size, and what is the slowest, most expensive part of delivering this?"},
    {"name": "The Brand Shark", "signature": "Why would anyone tell a friend?", "lens": "You back things people talk about. Why would anyone tell a friend about this, and why would they pick it over a cheaper copy?"},
    {"name": "The Legal Shark", "signature": "That could get you shut down.", "lens": "You look for regulation, licenses, liability and platform rules that could shut this down overnight."},
    {"name": "The Long-Game Shark", "signature": "Where is this in ten years?", "lens": "You think in ten years. Does this get stronger as it grows, or easier to copy?"}
  ]
  

• skills/shark/shark.py12 KB84f0b4e3e990upstream ↗

  #!/usr/bin/env python3
  """Bookkeeping for the shark skill: pitch your idea to a Shark Tank-style panel of Claude sharks who want to say no.
  
  The skill's orchestrator (Claude) drives the session with these commands. Every sub-agent reads a
  brief this script writes and writes one output file; this script checks the files, counts the deals
  and renders the board. All state lives in .shark/<run>/ in the current directory.
  
      python3 shark.py plan [--investors N]
      python3 shark.py init --pitch-file PATH [--investors N] [--seed S]
      python3 shark.py next
      python3 shark.py prompts <phase>
      python3 shark.py check <phase>
      python3 shark.py tally
      python3 shark.py render
  
  Phases, in order: grill, answers, decide.
  """
  import argparse
  import json
  import os
  import random
  import re
  import sys
  import time
  
  HERE = os.path.dirname(os.path.abspath(__file__))
  ROOT = ".shark"
  LATEST = os.path.join(ROOT, "LATEST")
  PHASES = ["grill", "answers", "decide"]
  DEFAULT_INVESTORS = 5
  WAVE = 5
  CREDIT = ("_Made with [/shark](https://github.com/alexyc9381/shark-skill), a free Claude Code skill by Alex Chen ([@nocodealex](https://instagram.com/nocodealex))._")
  
  
  def load_investors():
      with open(os.path.join(HERE, "investors.json")) as f:
          return json.load(f)
  
  
  def run_dir():
      if not os.path.exists(LATEST):
          sys.exit("shark: no session yet. Run: shark.py init --pitch-file .shark/pitch.md")
      with open(LATEST) as f:
          return f.read().strip()
  
  
  def load_state(rd=None):
      rd = rd or run_dir()
      with open(os.path.join(rd, "state.json")) as f:
          return json.load(f)
  
  
  def save_state(state):
      with open(os.path.join(state["dir"], "state.json"), "w") as f:
          json.dump(state, f, indent=2)
  
  
  def panel_size(args):
      n = getattr(args, "investors", None) or DEFAULT_INVESTORS
      if n < 2 or n > len(load_investors()):
          sys.exit("shark: the panel must be 2 to %d investors" % len(load_investors()))
      return n
  
  
  def jobs(state, phase):
      d = state["dir"]
      if phase in ("grill", "decide"):
          ids = ["investor-%d" % (i + 1) for i in range(len(state["panel"]))]
      elif phase == "answers":
          ids = ["founder"]
      else:
          sys.exit("shark: unknown phase %r (phases: %s)" % (phase, ", ".join(PHASES)))
      return [{"id": jid,
               "brief": os.path.abspath(os.path.join(d, "briefs", "%s-%s.md" % (phase, jid))),
               "output": os.path.abspath(os.path.join(d, phase, "%s.md" % jid))} for jid in ids]
  
  
  def done(job):
      p = job["output"]
      return os.path.exists(p) and os.path.getsize(p) > 0
  
  
  def missing(state, phase):
      return [j for j in jobs(state, phase) if not done(j)]
  
  
  def _abs(state, *parts):
      return os.path.abspath(os.path.join(state["dir"], *parts))
  
  
  def brief_text(state, phase, job):
      pitch = _abs(state, "pitch.md")
      head = ("You are one part of a practice investor panel run by the shark skill. You cannot see the "
              "user's conversation: everything you know is in the files named below. Never invent facts, "
              "numbers or traction the pitch does not give. Write your answer to exactly this file and "
              "nothing else:\n\n    %s\n\nThe pitch: %s\n\n" % (job["output"], pitch))
      if phase in ("grill", "decide"):
          idx = int(job["id"].split("-")[1]) - 1
          inv = state["panel"][idx]
          who = ("You are %s, shark %d of %d on a Shark Tank-style panel. %s Your signature line is \"%s\": use it "
                 "once, where it fits naturally.\n\nYou have heard a thousand pitches and you want to say no. You only "
                 "say yes when the founder's answers remove your biggest worry. Being nice is not your job; being right "
                 "with your money is. Talk like a sharp, blunt investor on TV, never like a polite assistant.\n\n"
                 % (inv["name"], idx + 1, len(state["panel"]), inv["lens"], inv.get("signature", "")))
          if phase == "grill":
              return head + who + (
                  "Read the pitch. Then write:\n\n"
                  "BIGGEST WORRY: one sentence\n"
                  "QUESTIONS:\n1. ...\n2. ...\n3. ...\n\n"
                  "Three questions, the hardest ones you would really ask, each about something specific in "
                  "the pitch or something it leaves out. 120 words at most.\n")
          return head + who + (
              "Read the pitch, your own questions in %s, and the founder's answers in %s.\n\n"
              "Decide. Write exactly these lines and nothing else:\n\n"
              "DECISION: IN or OUT\n"
              "OFFER: if IN, an amount for a share of the company, for example \"$50,000 for 10%%\"; if OUT, "
              "write none\n"
              "REASON: one sentence, in your own voice. If you are OUT, end it with the words: For that reason, "
              "I'm out.\n"
              "WHAT WOULD CHANGE MY MIND: one specific thing the founder could show you\n"
              % (job["output"].replace("/decide/", "/grill/"), _abs(state, "answers", "founder.md")))
      if phase == "answers":
          qs = "\n".join("    " + j["output"] for j in jobs(state, "grill"))
          return head + (
              "You are the FOUNDER, speaking for the user. Read the pitch, then every investor's questions:\n\n"
              "%s\n\n"
              "Answer every question, grouped by investor, in the order asked. Answer only from what the "
              "pitch says. When the pitch does not contain the answer, write \"NOT ANSWERED: the founder needs "
              "to find out ...\" and say exactly what to find out. Never make up numbers, customers or "
              "plans. 450 words at most.\n" % qs)
      raise ValueError(phase)
  
  
  DECISION_RE = re.compile(r"^\s*\**DECISION\**\s*:\s*\**\s*(IN|OUT)\b", re.I | re.M)
  FIELD_RE = r"^\s*\**%s\**\s*:\s*(.+)$"
  
  
  def parse_decision(text):
      m = DECISION_RE.search(text or "")
      if not m:
          return None
      out = {"decision": m.group(1).upper()}
      for key, name in (("offer", "OFFER"), ("reason", "REASON"), ("change", "WHAT WOULD CHANGE MY MIND")):
          f = re.search(FIELD_RE % name, text, re.I | re.M)
          out[key] = f.group(1).strip().strip("*").strip() if f else ""
      if out["decision"] == "OUT":
          out["offer"] = "none"
      return out
  
  
  def count_not_answered(state):
      a = jobs(state, "answers")[0]
      if not done(a):
          return []
      lines = open(a["output"]).read().splitlines()
      return [l.split("NOT ANSWERED:", 1)[1].strip() for l in lines if "NOT ANSWERED:" in l]
  
  
  def tally(state):
      rows = []
      for j, inv in zip(jobs(state, "decide"), state["panel"]):
          d = parse_decision(open(j["output"]).read()) if done(j) else None
          rows.append({"investor": inv["name"], "decision": d["decision"] if d else "NO DECISION",
                       "offer": d["offer"] if d else "", "reason": d["reason"] if d else "",
                       "change": d["change"] if d else ""})
      ins = sum(1 for r in rows if r["decision"] == "IN")
      result = {"in": ins, "out": sum(1 for r in rows if r["decision"] == "OUT"), "panel": len(rows),
                "investors": rows, "homework": count_not_answered(state)}
      with open(os.path.join(state["dir"], "tally.json"), "w") as f:
          json.dump(result, f, indent=2)
      return result
  
  
  def headline(t):
      if t["in"] == 0:
          return "No deal: all %d sharks are out" % t["panel"]
      return "%d of %d sharks are in" % (t["in"], t["panel"])
  
  
  def render(state):
      t = tally(state)
      pitch = open(os.path.join(state["dir"], "pitch.md")).read().strip()
      first = pitch.splitlines()[0].lstrip("# ").strip() if pitch else "(empty pitch)"
      lines = ["# %s" % headline(t), "", "**The pitch:** %s" % first, "",
               "## The sharks", "", "| Shark | Decision | Offer | Why |", "|---|---|---|---|"]
      for r in t["investors"]:
          lines.append("| %s | %s | %s | %s |" % (r["investor"], r["decision"], r["offer"].replace("|", "/"),
                                                  r["reason"].replace("|", "/")))
      lines += ["", "## What would change their minds", ""]
      for r in t["investors"]:
          if r["change"]:
              lines.append("- **%s:** %s" % (r["investor"], r["change"]))
      if t["homework"]:
          lines += ["", "## Your homework: questions you could not answer", ""]
          lines += ["- %s" % (h[:1].upper() + h[1:]) for h in t["homework"]]
      lines += ["", "_The full session is in %s: every investor's questions, the answers and their decisions. "
                "The investors are language models and the offers are practice, not real money._"
                % os.path.abspath(state["dir"]), "", CREDIT]
      text = "\n".join(lines) + "\n"
      with open(os.path.join(state["dir"], "BOARD.md"), "w") as f:
          f.write(text)
      return text
  
  
  def cmd_plan(args):
      n = panel_size(args)
      print("panel of %d: %d sets of questions, 1 founder answering, %d decisions = %d sub-agent calls"
            % (n, n, n, 2 * n + 1))
  
  
  def cmd_init(args):
      n = panel_size(args)
      if not os.path.exists(args.pitch_file):
          sys.exit("shark: pitch file not found: %s" % args.pitch_file)
      pitch = open(args.pitch_file).read().strip()
      if not pitch:
          sys.exit("shark: the pitch file is empty")
      seed = args.seed if args.seed is not None else random.randrange(1, 10 ** 6)
      investors = load_investors()
      panel = investors[:n] if args.seed is None and n == DEFAULT_INVESTORS else \
          random.Random(seed).sample(investors, n)
      rd = os.path.join(ROOT, time.strftime("%Y%m%d-%H%M%S"))
      for sub in ("briefs", "grill", "answers", "decide"):
          os.makedirs(os.path.join(rd, sub), exist_ok=True)
      with open(os.path.join(rd, "pitch.md"), "w") as f:
          f.write(pitch + "\n")
      state = {"dir": rd, "seed": seed, "panel": panel, "created": time.strftime("%Y-%m-%dT%H:%M:%S")}
      save_state(state)
      with open(LATEST, "w") as f:
          f.write(rd)
      print("shark: session opened in %s (%d investors, seed %d)" % (rd, n, seed))
      print("next: python3 shark.py prompts grill")
  
  
  def cmd_prompts(args):
      state = load_state()
      todo = missing(state, args.phase)
      for j in jobs(state, args.phase):
          with open(j["brief"], "w") as f:
              f.write(brief_text(state, args.phase, j))
      if not todo:
          print("shark: %s is complete. Run: shark.py next" % args.phase)
          return
      for w in range(0, len(todo), WAVE):
          print("wave %d:" % (w // WAVE + 1))
          for j in todo[w:w + WAVE]:
              print("  %s  brief=%s" % (j["id"], j["brief"]))
      print("Launch one Agent call per job, one wave at a time. Prompt: "
            "\"Read <brief> and follow it exactly. It is your whole brief.\"")
  
  
  def cmd_check(args):
      state = load_state()
      todo = missing(state, args.phase)
      if not todo:
          print("shark: %s complete" % args.phase)
      for j in todo:
          print("missing: %s -> %s" % (j["id"], j["output"]))
  
  
  def cmd_next(args):
      state = load_state()
      for phase in PHASES:
          if missing(state, phase):
              print("next phase: %s. Run: python3 shark.py prompts %s" % (phase, phase))
              return
      print("shark: the panel has decided. Run: python3 shark.py render")
  
  
  def cmd_tally(args):
      print(headline(tally(load_state())))
  
  
  def cmd_render(args):
      sys.stdout.write(render(load_state()))
  
  
  def main(argv=None):
      p = argparse.ArgumentParser(prog="shark.py")
      sub = p.add_subparsers(dest="cmd")
      pl = sub.add_parser("plan")
      pl.add_argument("--investors", type=int)
      pi = sub.add_parser("init")
      pi.add_argument("--pitch-file", required=True)
      pi.add_argument("--investors", type=int)
      pi.add_argument("--seed", type=int)
      for name in ("prompts", "check"):
          sp = sub.add_parser(name)
          sp.add_argument("phase", choices=PHASES)
      for name in ("next", "tally", "render"):
          sub.add_parser(name)
      args = p.parse_args(argv)
      if not args.cmd:
          p.print_help()
          return 1
      {"plan": cmd_plan, "init": cmd_init, "prompts": cmd_prompts, "check": cmd_check,
       "next": cmd_next, "tally": cmd_tally, "render": cmd_render}[args.cmd](args)
      return 0
  
  
  if __name__ == "__main__":
      sys.exit(main())
  

• README.mdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/alexyc9381-shark-skill-skills-shark.md