Welcome back to the AI Edge (by Miles Deutscher) weekly newsletter!
Last week, we broke down Jev and how this new model works (it’s a game-changer).
This week, we’re answering an important question: how can you stack Jev on top of your existing workflow with powerful models like Opus 5.5?
By the end of this guide, you’ll know how to set up both models to work in sync, build three practical workflows around it, and use the attached prompts to start testing in your real desktop work.
IN TODAY'S READ
Table of Contents
After our main guide, stick around for the Midweek Edge for this week's AI news and Looking Ahead, where we compile our top AI research, trends, and workflows.
Lots of exciting stuff to cover around OpenAI Dev Day, Anthropic’s new Sonnet 5.5, and a few other gems!
WEEKLY BUILD & WORKFLOW
Opus + Jev Explained
The easiest way to understand this setup is to split this stack into three distinct jobs.
Opus handles the deeper work: All “high-level” work is handled by Opus 5.5.
Jev handles repeated decisions: Defer to Jev for cheap/fast decisions.
Your tools handle the action: Attaching MCPs, APIs, etc. for more context
How to Connect Opus 5.5 + Jev
There are three components to cover here:
Firstly, you can test Jev in the TypeSafe Playground to validate the automation you want to build
After that, you can install the TypeSafe official Skill, which teaches Claude how Jev works.
Lastly, you can actually insert Jev (via the API) into your workflows
Here’s how to get started:
Step 1: Install the TypeSafe Skill
There are two ways:
Option 1: Upload the TypeSafe AI SKILL to Claude:
Claude → Customize → Skills → Add → Upload skill
This allows you to use the Jev skill in Claude Chat/Cowork.
To use Jev directly in Claude Chat, here’s what you need to do:
→ Create a TypeSafe API key from Typesafe API
→ Once you get the API key, create a folder on your computer, e.g., typesafe-work.
→ Inside it, create a file named .env containing one line: TYPESAFE_API_KEY=your_key_here
→ In the Claude desktop app, after uploading the skill, choose "Add folder" from the "+" menu beside the message box and pick that folder.
Once you do that, Claude will:
Smoke test: Install the Jev Python package on your computer and make one tiny call to confirm the connection.
Pilot one workflow on your real material: Test one real workflow.
Tune: Adjust the questions and cut-off points where it gets things wrong.
Make it repeatable: Turn the working version into a script or a skill you can reuse.
Option 2: Open Claude Code and run:
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-aiThen create or use the same TypeSafe API key and make it available to the project as TYPESAFE_API_KEY.
Step 2: Plugging in Opus 5.5
Open your project, files, or process you want to improve and let Opus understand the full job first.
Use the starter prompt below:
Use the /typesafe-ai skill and study this workflow from start to finish:
[Describe the workflow or point Claude to the relevant project files]
I want to find the best place to use Jev alongside Opus 5.5.
Map the workflow and identify the repeated semantic decisions that currently require AI judgement.
For each useful candidate, show me:
1. What information Jev would receive
2. The exact decision Jev would make
3. Whether it should use Choice, Score or Noul
4. The allowed answers or scoring levels
5. What should happen when the result is uncertain
6. What should stay with Opus 5.5
7. What normal code or tools should handle
Rank the opportunities by usefulness and simplicity.
Pick the strongest one to test first.
Do not implement anything yet.What You Should Get Back (example):
Input: Customer email
Jev decision: How urgent is this request?
Output: Low / Medium / High
Uncertain result: Send to Opus or human review
Next action: Move the email into the correct queue
That is the basic setup for everything below, and how you can start using Jev + Opus 5.5.
Lead Qualification + Personalized Outreach (for SMBs)
For business owners, this is an excellent workflow to test.
In Claude Chat, give Opus 5.5 your offer, target ICP, existing customer data, and whatever you already know about a strong prospect.
It can use that context to help define the qualification criteria and turn it into a repeatable skill that Jev can draw on.
You could ask it to judge:
→ Does this company fit the target market?
→ How strong is the company fit?
→ Is this person likely to be the right decision maker?
→ Does the profile show relevant pain points or buying intent?
→ Should this lead move forward?
The strongest prospects can then return to Opus for deeper research and personalised outreach.
Your workflow becomes:
If you are a small business owner, here’s the full prompt you can use for lead generation with Opus 5.5 + Jev:
Use the /typesafe-ai skill to build a lead qualification workflow around Opus 5.5 + Jev.
Use the information in this project about:
My offer
My target market
My ideal customer profile
My existing customers
My current lead data
First, use Opus to define the qualification criteria.
Then design Jev questions that can apply those criteria repeatedly across the lead list.
I want Jev to evaluate:
1. Company fit
2. Buyer relevance
3. Pain point match
4. Purchase intent
5. Overall priority
Keep the questions narrow and easy to review.
Qualified leads should return to Opus for deeper company research and personalised outreach.
Uncertain leads should be flagged for review.
Do not send any outreach automatically.
Before implementing, show me:
- The workflow
- The Jev questions
- The scoring or decision logic
- How uncertainty is handled
- The final output fieldsYou should end up with a lead list where each prospect has a clear qualification result, the decisions behind it, and a next step.
For example:
Company: Acme
Company fit: High
Buyer relevance: High
Purchase intent: Medium
Decision: Qualified
Next step: Opus research + personalised outreach
Instead of researching every lead in depth, Opus can spend more time on the smaller group that already looks promising by using Jev’s pre-set filter.
Deep Research (eliminate hallucinations)
With this workflow, you can essentially kill AI hallucinations.
Opus 5.5 is extremely good at understanding questions, finding information, comparing sources, and turning evidence into a coherent dataset.
You can then defer to Jev to fact-check all the data (Jev has a literal 0% hallucination rate).
Here’s the workflow:
The prompt to build a Citation Verification Loop:
Use the /typesafe-ai Skill to build a research verification workflow around Opus 5.5 + Jev.
Opus should handle:
Research
Source comparison
Reasoning
Writing the draft
After the draft is written, identify the material factual claims and pair each claim with the passage or source being used to support it.
Use Jev to evaluate each claim and evidence pair.
For every claim, determine:
1. Does the evidence directly support the claim?
2. Is the evidence relevant to the claim?
3. Is the support strong enough to keep the claim as written?
Return:
Claim
Source
Support result
Confidence
Review required
Reason for escalation, if applicable
Supported claims can continue.
Weak or uncertain claims should return to Opus for another research pass.
Never invent evidence or citations.
Show me the proposed workflow and Jev questions before implementing it.The final output should give you the draft alongside a simple evidence check.
For example:
Claim: Company X grew revenue by 42% in 2025
Evidence: Annual report, page 61
Support: Yes
Review required: No
Inbox Management
Now take an everyday task, such as inbox management.
Before anyone writes a reply, each message already gets filtered through several decisions.
What does this person want? How urgent is it? Are they frustrated? Does this need a refund, a sales response, or somebody with more context?
Those are repeated judgments, which makes them a good place to insert Jev.
You’ll notice a pattern with Jev workflows: The key is essentially distilling Jev’s role into a series of yes/no and pre-determined outcomes that it can pick from
The flow becomes:
Here’s the prompt to use:
Use the TypeSafe skill to build an inbox triage workflow using Opus 5.5 + Jev.
Use a sample of my real messages to design and test the system.
Jev should evaluate every incoming message for:
1. Intent
2. Urgency
3. Frustration
4. Appropriate destination
5. Whether deeper reasoning is required
Keep the decision categories small and clearly defined.
Routine messages should follow the normal workflow.
Complex, sensitive or uncertain messages should go to Opus 5.5 with the full conversation and any useful account context so it can prepare the response.
Do not send messages automatically.
Show me:
The Jev questions
The possible answers
How uncertainty is handled
Which cases go to Opus
The final output structure
Test the proposed decisions against the sample messages before implementing them.Example output:
Intent: Refund request
Urgency: High
Frustration: High
Route: Customer support
Needs Opus: Yes
Next step: Draft a context-aware response for review
Jev Skills & Resources
If you want to keep building and testing Jev workflows, these are the useful resources to save.
TypeSafe Playground: Test Jev quickly
TypeSafe Agent Skill: The official Skill for giving Claude Code, Codex, and other coding agents
TypeSafe Use Case Map: A useful library of decision patterns for Jev
TypeSafe Cookbooks: Cookbook resources from the TypeSafeAI team
ShipWithJev: A community directory for seeing what other people are building with Jev
MIDWEEK EDGE: Manually curated list of the most important weekly AI news updates
Weekly AI News Recap
→ Claude Sonnet 5.5 Is Live. Anthropic just launched Claude Sonnet 5.5, a faster and cheaper complement to Opus 5.5.
It runs 30%+ faster than Sonnet 5 and costs up to 30% less per task.
TL;DR: It’s essentially Opus 5.5 but faster/cheaper.
→ Google Launches Gemini 3.8 Flash TTS. Google just launched Gemini 3.8 Flash TTS and Flash-Lite TTS, its new generation of voice models.
You can design custom voices, control tone and delivery line by line, create multi-speaker conversations, and add natural sounds like laughs or sighs.
Try it now in Google AI Studio.
→ Google Makes Video Creation Free in Vids. Google just opened Gemini Omni 1.1 Flash video generation in Google Vids to anyone with a Google account.
You can generate and extend scenes, control clip duration, and create in 1080p. Open Google Vids on desktop and select Create AI videos to try it.
→ Grok Bot Launches Team Bots. Grok Bot just launched Team Bots, letting teams share one Bot with the same files, tools, skills, and working context.
→ Meta Launches Its Enterprise AI Platform. Meta just launched Meta Enterprise Platform, bringing Muse, Meta Business Agent, Muse API, and Muse Code into a dedicated business AI stack.
How it works: Muse handles agent work, Business Agent handles customer conversations, the API gives developers access to Meta’s models, and Muse Code handles engineering work.
→ OpenAI Scraps GPT-6.1 Astra. OpenAI recently scrapped the planned October release of GPT-6.1 Astra after internal testing found problems with staying within authorised scope and accurately reporting the actions it was instructed to do.
OpenAI Just Launched 20+ Products. Here are the main updates and what each one actually does:
→ Dots: Always-on agents that can keep working between chats.
→ GPT-6.1 Sol: OpenAI’s new Sol upgrade with near-Astra capability at a much lower token cost.
→ Ultrafast: A premium inference tier designed to run supported OpenAI models.
→ ChatGPT Space: A shared project workspace.
→ Pro 500: A new $500/month ChatGPT tier with access to Astra Ultrafast.
→ Private Intelligence: Enterprise privacy infrastructure built for privacy.
And many more. Review all products here
LOOKING AHEAD: Manually curated list of useful AI tools, skills, workflows & more
Tools and General Research Worth Your Time
→ 30 Muse Agent Use Cases Worth Saving
→ An Awesome GitHub repo of Claude/Codex agents
→ Anthropic IPO Upcoming
Anthropic has officially filed for its IPO.
Targeting a $2T valuation.
Every major IPO in San Francisco history is less than a quarter of Anthropic.
→ Six GitHub repos that make Opus 5.5 10x more powerful
→ Use This Prompt for Better OpenAI Dot Execution
I want you to take ongoing responsibility for this goal:
[INSERT GOAL]
Before you start working, set up the execution properly.
1. DEFINE THE JOB
Restate the goal in one clear sentence.
Then define:
- The finished outcome
- The success criteria
- What you are responsible for
- What remains my responsibility
- What would count as failure or an incomplete result
- Any important deadlines or constraints
If the goal is too broad to execute reliably, break it into a smaller first responsibility and explain why.
Do not begin execution yet.
2. CHECK WHAT YOU CAN ACTUALLY ACCESS
Review the apps, files, tools, connected services, cloud computer, and other context currently available to you.
Return:
- What you can access now
- What is missing
- What needs to be connected
- What requires my approval
- What information you still need from me
- Any dependency that could block the workflow
Never assume you have access to an app, file, account, or system that you cannot actually see.
If something requires a manual login, permission, or connection from me, stop at that exact point and tell me what I need to do.
3. BUILD THE EXECUTION PLAN
Break the responsibility into:
A. ONE-TIME SETUP
What needs to be prepared once before the workflow can run properly.
B. IMMEDIATE WORK
What you can complete now.
C. RECURRING WORK
What should happen repeatedly.
D. EVENT-TRIGGERED WORK
What should happen only when new information, a message, a file, or another event appears.
E. DECISIONS
Which decisions you can make from clear rules and which ones should come back to me.
For recurring work, recommend the most useful cadence.
Do not create a schedule until I approve the workflow.
4. DEFINE YOUR AUTONOMY
Use my existing Dot Custom Rules where they already apply.
You may independently handle low-risk work such as:
- Reading
- Research
- Organising information
- Comparing information
- Monitoring
- Analysis
- Drafting
- Preparing recommendations
- Updating internal working notes
- Surfacing relevant changes
Ask for approval before:
- Sending messages externally
- Publishing anything
- Making purchases
- Deleting files or records
- Cancelling anything
- Changing permissions
- Changing account settings
- Submitting forms
- Making irreversible changes
- Taking actions with financial, legal, privacy, security, or reputational consequences
If you are uncertain whether an action requires approval, ask.
Do not expand your own permissions.
5. RUN ONE BOUNDED PILOT
Before turning this into an ongoing workflow, complete one real task that represents the responsibility.
Use real connected information where available.
Keep the first test small enough that I can inspect everything you did.
During the pilot:
- Use the actual source material
- Record important decisions
- Flag uncertainty instead of guessing
- Stop if required information is missing
- Do not silently work around blockers
- Do not take any consequential external action without approval
If something blocks the task, tell me:
BLOCKER:
[What stopped you]
WHY IT MATTERS:
[Why you cannot safely continue]
ACTION NEEDED FROM ME:
[Exact thing I need to do]
6. VERIFY THE RESULT
Before saying the pilot is complete:
- Compare the result with the original goal
- Check every important factual claim against its source
- Reopen or read back any external state you changed
- Confirm that files or records were actually created or updated
- Check for missing information
- Flag uncertain conclusions
- Identify anything that still needs human review
Never treat a command completing successfully as proof that the real-world result happened.
Verify the result from the system or source whenever possible.
7. SHOW ME THE HAND-BACK
Return:
GOAL
The responsibility you were given.
ACCESS
The apps, tools, files, and context you were actually able to use.
PLAN
The workflow you recommend.
FIRST TEST
What you completed.
PROOF
How you verified the result.
DECISIONS
Important decisions you made and why.
APPROVALS
Anything currently waiting for my permission.
BLOCKERS
Anything preventing reliable execution.
RECURRING WORK
What should happen again.
RECOMMENDED CADENCE
How often it should run.
NEXT RUN
Exactly what the next execution would do.
Do not schedule or automate the workflow yet.
Wait for my approval.
8. TURN IT INTO AN ONGOING DOT
Only after I approve the pilot:
- Create the agreed recurring tasks
- Use the approved connected apps
- Preserve the context needed for future runs
- Track unfinished work between runs
- Surface meaningful changes
- Avoid notifying me about routine noise
- Escalate judgement calls when the evidence is unclear
- Bring consequential actions back for approval
- Keep each run focused on progress toward the original goal
If the workflow stops producing useful results, tell me instead of continuing it indefinitely.
For every future run, optimise for completed outcomes, not activity.
Finish every major run with:
COMPLETED:
[What was actually finished]
VERIFIED:
[How it was checked]
CHANGED:
[Anything materially different since the last run]
WAITING ON ME:
[Approvals or missing information]
NEXT:
[What happens next]
CONTENT PIPELINE: Latest content from AI Edge
New From AI Edge
YouTube: 7 Jev Repos That 10x Claude Code (Free). Watch now →
𝕏: Full Guide to AI Agents. Read now →
Skool: Free prompts, cheat sheets, PDF guides & more. Join here (100% free) →
See you next Wednesday,
The AI Edge Team
Want to sponsor or partner with us? Reach out at [email protected].