Claude Writes, Jev Decides: LinkedIn Marketing Stack

By the end of this playbook you will have:

• A TypeSafe / Jev API key and a verified smoke call (noul / choice / score)
• The official TypeSafe skill installed in Claude Code so Claude writes glue code while Jev returns typed decisions
• An editable ICP decision contract (questions + thresholds) you can version in a repo or Sheet
• A LinkedIn radar that scores niche posts / profiles fetched from exports or documentable third-party connectors — not a native LinkedIn “magic API”
• A lead scoring lane that writes Hot / Warm / Cold rows to Google Sheets (or your CRM staging sheet)
• A content engine: Claude drafts posts/comments; Jev gates quality/fit; you approve before anything ships
• A reply desk for hot DMs/comments: Jev triages urgency + intent; Claude drafts; humans send
• Cost math against official Jev pricing so you know what “cheap decisions” actually means

1. TypeSafe account — early access at typesafe.ai; create an API key in the dashboard and store it as TYPESAFE_API_KEY (password manager, not chat history).
2. Claude Code installed and logged in (Anthropic account / Claude subscription that supports Claude Code on your machine).
3. Python 3.10+ or Node 18+ for the official SDK path (typesafe-sdk or @typesafe-ai/sdk) — optional if you only use cURL at first.
4. A Google Sheet (or CSV) you own for radar + scoring rows — columns you control: source_url, snippet, author, company, raw_state, tier, confidence, notes.
5. A legal data path for LinkedIn-ish inputs: LinkedIn CSV export, Sales Navigator export your policy allows, and/or a documentable connector your counsel accepts (common patterns: Apify actors, Periodix Actions, HeyReach webhooks). Do not paste stolen session cookies into random scripts.
6. Optional orchestration: n8n (self-host or Cloud) for schedules + Slack approval cards — see n8n HITL gates once the decision contract works by hand.

Fetch state elsewhere  →  Jev (typed decide)  →  Claude (write/research)  →  Human approve  →  Send via approved tool

Third-party operators publish LinkedIn “radar” tutorials built this way. Treat those as industry anecdotes, not TypeSafe case studies and not Octacer performance claims.

1. Sign in at typesafe.ai → open the dashboard → create an API key.
2. Export it in your shell (or Claude Code env):

export TYPESAFE_API_KEY="ts_..."   # never commit this

1. Run the official smoke shape (docs: Quick start):

curl -sS -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "VP Sales at a 80-person B2B SaaS. Posted: looking for a lightweight approval layer before AI agents write to HubSpot.",
    "model": "jev-latest",
    "questions": {
      "icp_fit": {
        "type": "noul",
        "instructions": "Is this person a plausible buyer for governed AI ops / HITL automation in mid-market B2B?"
      },
      "lane": {
        "type": "choice",
        "instructions": "Which outreach lane fits best?",
        "criteria": {
          "radar_engage": "Public post worth a thoughtful comment",
          "outbound_dm": "Direct outreach candidate",
          "nurture": "Interesting but not now",
          "skip": "Wrong ICP or noise"
        }
      },
      "priority": {
        "type": "score",
        "instructions": "How hot is this lead for a discovery call this month?",
        "criteria": ["Cold", "Warm", "Hot"]
      }
    }
  }'

1. Confirm the JSON returns answers.icp_fit.noul, answers.lane.choice, and answers.priority.score plus usage.input_tokens.
2. Optional SDK installs:

pip install typesafe-sdk
# or
npm install @typesafe-ai/sdk

Jev is not a Claude chat model swap. The verified Claude path is TypeSafe’s agent skill/plugin, which teaches Claude Code how to compose System One calls.

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

Alternative (Codex / other agents via skills.sh):

npx skills add typesafe-ai/skills --skill typesafe-ai

Then in Claude Code:

1. Restart or /reload-plugins if needed.
2. Invoke /typesafe:typesafe-ai or say “use the TypeSafe skill.”
3. Prompt something like:

Use the TypeSafe skill. Build a small Python CLI that reads rows from a CSV
(state text + url), calls Jev with my ICP questions (noul + choice + score),
and writes tier/confidence/token usage to an output CSV. Pin model jev-1.13.0.
Do not send LinkedIn messages. Ask me for the exact ICP criteria before coding.

Create icp-questions.json (or a Sheet tab) you can diff in Git. Example for Octacer-shaped B2B automation buyers — edit hard for your niche:

{
  "icp_fit": {
    "type": "noul",
    "instructions": "Buyer-side ops/RevOps/IT leader at B2B software or services, 20–500 staff, who cares about approvals before AI writes to CRM/ERP."
  },
  "persona": {
    "type": "choice",
    "instructions": "Best-fit persona",
    "criteria": {
      "revops": "Revenue ops / CRM owner",
      "it_ops": "IT / platform / automation owner",
      "founder": "Founder/CEO still in the weeds",
      "other": "Not a fit or unclear"
    }
  },
  "intent": {
    "type": "score",
    "instructions": "Strength of buying/intent signal in the supplied text",
    "criteria": ["No intent", "Soft curiosity", "Active evaluation"]
  }
}

Calibration drill (do this before bulk runs):

1. Label 30–50 real rows yourself (Hot / Warm / Cold or Skip).
2. Score them with Jev; log choice, probabilities, confidence, and input tokens.
3. Set thresholds in code (e.g. Hot only if icp_fit.noul >= 0.75 and intent.score >= 1.5 and confidence above your floor).
4. Fail closed on low confidence → needs_human queue.

Goal: every morning, a short list of posts worth engaging — scored, not doom-scrolled.

1. Ingest into Sheets (pick one documentable path):

• Manual: paste post URL + copied text into raw_state.
• Export: LinkedIn / Sales Nav CSV your account is allowed to download → Claude Code normalizes columns.
• Connector: n8n + Apify LinkedIn/profile actors, or Periodix Actions (LinkedIn post search patterns exist as n8n templates), writing authors + post text into the same Sheet.

1. For each new row, build state as plain text: headline, company, post body, your niche keyword, date (date logic stays in code).
2. Call Jev with questions such as: worth_comment (noul), angle (choice: product story / founder lesson / hiring / noise), priority (score).
3. Code routes: worth_comment >= threshold → Radar Hot tab; else Cold/Archive.
4. Claude (batch or per-row) drafts one thoughtful comment for Hot rows only — still not posted.
5. You approve in Sheet checkbox or Slack HITL; then you (or an approved outreach tool) post manually.

Goal: connection requests, CSV dumps, and event attendees become tiered queues.

1. Put profile blobs in raw_state (About + experience + recent post titles is enough; strip emails you do not need).
2. Reuse the ICP contract; add a outbound_ready noul: “Is a short, non-spammy connection note justified this week?”
3. Write results to columns: tier (Hot/Warm/Cold/Skip), persona, intent_score, confidence, input_tokens, model.
4. Only Hot (+ maybe Warm) go to Claude for a personalized note draft stored in draft_note.
5. Human approves; send via native LinkedIn UI or a tool you already pay for (e.g. HeyReach campaign add via n8n — HeyReach documents an n8n key + nodes). Jev never sends.

Worked token math (official price $0.042 / 1M input tokens, output free):

Goal: a week of niche posts without posting slop.

1. Collect inputs in a content_inbox Sheet: customer quotes, release notes, war stories, competitor public moves (facts you can defend).
2. Claude drafts 3–5 post variants (hook + body + CTA) into drafts.
3. Jev scores each draft with a caller-defined rubric, for example:

• on_brand (noul)
• format (choice: story / how-to / opinion / soft CTA)
• ship_readiness (score: Needs work / Almost / Ship)

1. Auto-reject drafts below threshold; Claude revises losers once; winners enter #content-approvals.
2. Human picks the final; schedule in your usual publisher (native LinkedIn, Buffer, etc.).

Do not ask Jev to “write a LinkedIn post.” Ask it to judge drafts Claude already wrote.

Goal: never leave money (or landmines) sitting in Unibox.

1. Ingest inbound comments/DMs via export, HeyReach Unibox/webhook (documented with n8n), or manual paste into inbox_raw.
2. One Jev call per message:

• needs_human_now (noul) — legal, pricing commitment, angry customer
• intent (choice: buy / partner / spam / support / unclear)
• tone_risk (score: Safe / Careful / Escalation)

1. Code routing:

• Escalation or needs_human_now high → Slack @owner immediately, no auto-draft send
• buy/partner mid confidence → Claude drafts reply → HITL approve → human sends
• spam → archive

1. Log every decision with model version + tokens for audit.

Once Steps 1–7 work manually:

1. Schedule an n8n workflow: cron → read Sheet rows with status=new → HTTP Request to https://api.typesafe.ai/v1/systemone with TYPESAFE_API_KEY → Code node applies thresholds → update Sheet + Slack message.
2. Put Human review in front of any node that adds leads to a HeyReach campaign or posts externally (HITL playbook).
3. Keep Claude drafting in a second lane (Claude Code batch job or n8n Anthropic node) after Jev says the row is worth it — saves writer tokens.

• [ ] Smoke cURL returns typed answers + usage.input_tokens
• [ ] TYPESAFE_API_KEY only in env/secret store
• [ ] Claude Code TypeSafe skill installed; agent can generate a correct System One call
• [ ] ICP questions checked into Git; 30+ labeled rows used to set thresholds
• [ ] Model pinned (jev-1.13.0) after calibration
• [ ] Radar Hot tab reviews clean for one week of niche keywords
• [ ] Lead scoring writes tiers without sending messages
• [ ] Content drafts gated by Jev rubric before publish
• [ ] Reply desk escalations hit a human; no auto-send on low confidence
• [ ] Token usage logged; monthly Jev $ matches the math above (plus separate Claude/connector bills)
• [ ] Legal/privacy review done for LinkedIn data path and TypeSafe processing terms

• Treating Jev like Claude — it will not browse LinkedIn or write essays; it answers your schema.
• “Zero hallucination” marketing — schema is bounded; judgments can still be wrong. Validate locally.
• Cookie scrapers as the default — prefer exports and vendors whose docs you can show counsel; respect LinkedIn terms.
• Thresholds without labels — you will over-message or starve the pipeline.
• Stuffing huge states — burns tokens and hits the 32k state/question guidance; summarize in code first.
• Auto-approve outreach — breaks the whole point of a decision stack.
• Claiming vanity metrics you did not earn — keep Octacer copy about the system, not third-party impression screenshots.

Is this a native LinkedIn + Claude product from TypeSafe?
No. Official pieces are Jev (System One API), SDKs, and the Claude Code skill. LinkedIn data and send paths are third-party or manual.

Can I call Jev from Vercel AI SDK?
Vercel documents typesafe-ai/jev via AI Gateway / experimental_evaluate as an evaluation-model path — useful in apps, still not a LinkedIn integration.

What about free credits?
Promotional credits are account-specific; do not plan production budgets on unverified “$5 free” rumors. Use dashboard balance + the $0.042/1M math.

Where do Make.com or chatbots fit?
If your team already lives in Make, use it as the scheduler/Sheet glue the same way as n8n. For customer-facing FAQ bots, keep a separate governed chatbot lane — see related playbooks below.

Add hard gates on anything that writes or sends: n8n Human-in-the-Loop Tool Gates. For broader ops agents on your own metal: Self-Host n8n AI Ops Agent. For Sheets/CRM tool wiring into Claude: Business MCP Starter Pack.