Saturday's @activibe_ai dinner brought Toronto's tech & AI creators under one roof. Met so many incredible people, saw guitars on the blockchain and wearables made from computer chips, and left way more motivated to create. Thank you Sasha for making it happen 🙌
1
14
The “one prompt” part of these Opus demos is honestly the least interesting part to me.
Because a 30-word prompt making a crazy video looks impressive, but it doesn’t tell you much about how to consistently make the next 50 videos.
The part I found way more useful here is the idea that the prompt is only 10% of the system. The other 90% is the harness.
Give the model references.
Give it a proper render setup.
Give it rules for what good looks like.
Let it render.
Then make it actually look at the frames, find the worst problems, fix them and run again.
That’s a completely different way of thinking about AI video.
You’re not asking:
“Can Opus make a good video?”
You’re asking:
“Can I build a system where Opus keeps getting closer to a good video without me sitting there directing every frame?”
And the reference workflow is probably the biggest unlock here for me. Instead of saying “make it look premium”, give it an actual frame or video, make it extract the visual language, turn that into a style guide, then build from there.
That’s how a cool demo becomes an actual production system.
The model is getting better.
But the real advantage is building the system around it.
67
The thing I keep thinking about after reading this is that most marketers are probably using AI way too manually.
They open ChatGPT, give it a prompt, get an answer, copy it somewhere and repeat the same thing tomorrow.
That’s not really a system.
The interesting part here is connecting the whole thing.
Your customer research feeds the campaign brief.
The brief feeds production.
The campaign results go back into the knowledge base.
Then the next campaign starts with everything you learned from the last one.
That changes how I think about AI in marketing.
The value isn't just having an agent write your LinkedIn posts or research competitors.
It’s making sure the agent actually knows your audience, offer, previous campaigns, results and how you work.
And I like the advice to start with one vertical.
Don't try to build some massive AI marketing OS on day one.
Take one thing you already do every week.
Build the workflow around it.
Use it.
See where it sucks.
Fix the context and instructions.
Then keep adding to it.
That feels much closer to how marketing teams will actually use agents.
1
45
The part I actually liked here is the idea of not using more agents just because you can.
I see a lot of people building agent systems where the answer to every problem is “add another agent.”
More agents.
More orchestration.
More tools.
And suddenly a simple workflow needs 17 agents to send an email.
The setup here is much more practical.
Have one small agent running the boring stuff continuously.
Then give it a simple rule:
if this gets too wide, call the swarm.
That’s the interesting part to me. The small agent isn't trying to be the smartest thing in the system. It’s deciding when the problem is big enough to deserve more compute.
And keeping the human in the middle makes sense too.
The swarm can spin up hundreds of agents, but you still decide whether the task is actually worth the cost.
Feels like a much better way to build agent systems.
Don't start with 300 agents.
Start with one boring workflow.
Make it run without you.
Then give it a way to know when it needs help.
That’s when agents start feeling less like demos and more like actual infrastructure.
19
I think we’ve been looking at scaling AI models the wrong way.
For the last few years it was basically:
more data
more parameters
more compute
make the model bigger and hope intelligence goes up.
The interesting thing about Astra is that you can keep the model the same and give it more compute only when the problem actually needs it.
Easy task? Don't waste compute.
Hard problem? Let it go around the loop a few more times.
That sounds simple, but I think this could matter a lot for the economics of AI.
You don't need every request to use the maximum amount of intelligence.
You need the model to know when it needs more intelligence.
That’s the part I find more interesting than another benchmark going up.
And there’s a weird second-order effect here too.
If more of the actual reasoning happens inside the model before it generates anything, then the text we see from the model becomes an even worse representation of what actually happened internally.
So maybe the next big jump isn't just better models.
It’s models getting better at deciding how much thinking a problem deserves.
14
Build Your Own AI Employees on GPT-6 Astra: The A–Z Agent Playbook
The to-do list on your laptop is honest. It moves when you sit down. It freezes when you stand up.
You know the morning. Inbox first. Three forms that were “quick” last Tuesday. A person you have chased twice who still has not sent the file.
You answer, you nudge, you fill, you paste the same paragraph into a new window. By noon the list looks like last night, only heavier.
That is not a willpower problem. That is a company with one employee, and the employee is you.
I used to treat GPT-6 Astra like a very fast colleague in a chat box. I sat with it. I steered it.
The work advanced in the minutes I was looking. The minute I left, the company clocked out.
GPT-6 Astra was still fast. The company was still me.
Then I hired the work into homemade agents and put GPT-6 Astra underneath them as the engine. One agent owned triage. One owned the form pack. One waited for a handoff, then wrote the chase notes.
I shut the lid. When I opened it, the result was not a wall of chat. It was a dated folder: a one-page brief, a draft pack, and an action log of who had been pinged and who still needed a human.
GPT-6 Astra is the engine. Your homemade agents are the employees.
This is the A–Z playbook for standing up that roster on a laptop, a VPS, or a cloud computer you actually control.
Seven steps. Stop after the first and you still have a hire. Run all seven and the week can move when you are not in the chair.
Hire one agent and shut the lid.
Write the charter, then leave it alone.
Give tools and logins once.
Put GPT-6 Astra behind every agent.
Hire the rest by what they own.
Make agents hand work to each other.
Put the roster on a schedule.
Step 1 · Hire one agent and shut the lid
Start with one body of work that already has a finish line. Not “help me with ops.” A job you could hand a careful intern on a Friday and check on Monday.
The first hire is Owen, in miniature. Weekly ops: the unanswered inbound, the form that is always almost done, the person who was supposed to send the file.
Give the agent a name, a folder, and a definition of done that lives on disk.
Name: Owen. Owns: the weekly residue pack. Done: a dated folder with three artifacts. A one-page brief of what arrived. A draft of the recurring form, unsubmitted. An action log of chases written, not sent.
That last clause matters. The first agent does not get to touch the outside world. It prepares. You still press send, submit, and pay.
Run the job once while you watch. You need the shape of a good finish before you trust a closed lid.
Judge the run by the folder, not the chat. If the brief, the draft, and the log are there, the hire worked.
If the chat is brilliant and the folder is empty, the hire failed. A transcript is not a shift. A folder is.
The second run is the real interview. Same job. Same folder pattern.
This time you shut the lid. Go make coffee. Come back to the artifact, not to a conversation that needs you to keep it alive.
A homemade agent is not a prompt you retype. It is a small runtime on your machine: a role file, a workspace, permission to use a browser and a filesystem, and an instruction to stop when the artifacts exist.
GPT-6 Astra is what thinks inside that loop. The agent is the employee who was told what “done” looks like.
GPT-6 Astra is not the intern. The intern is the agent you named and left.
Keep the first job boring on purpose. Boring is measurable. “Summarize my life” is not, and “build me a company” is not.
“Put last week’s inbound into ops/2026-09-14/ with a brief, a draft, and a log” is a job an employee can finish without you.
Three tests before you promote this agent.
The lid test. You left. The folder still appeared.
The stranger test. Someone who is not you can open the folder and know what happened.
The repeat test. Tuesday’s pack looks like Monday’s pack, same bones, new facts.
Lid. Stranger. Repeat.
Fail the lid test and you still have a chatbot. Fail the stranger test and you still have a diary. Fail the repeat test and you still have a one-off.
GPT-6 Astra can pass a chat. Only the folder proves an employee.
Pass all three, and you have an employee. Do not hire the rest of the roster yet. One clean hire teaches you more than five overlapping personalities.
When the folder is real, write down what you will never again accept as a result: a transcript, a vibe, a “let me know if you want me to continue.” GPT-6 Astra can talk forever. Your agent should stop.
Step 2 · Write the charter, then leave it alone
A charter is the employment contract. A daily brief is today’s assignment. Most people smash them into one blob and then wonder why the agent gets dumber every morning.
Write the charter once, as a file the runtime loads every run. The charter does not change because you slept badly. The brief does.
Stop editing the contract for sport.
Five fields. Outcome. Sources. Constraints. Deliverable. Review point.
No more on the first hire. If a field is missing, you hired a chatbot with a name.
Outcome. The change in the world when the job is finished. Not the activity. “The partner pack for this week exists and is ready for my review” is an outcome. “Look through email” is a hobby.
Sources. Where the agent is allowed to look. Inbox labels. A drive folder. A CRM view. A URL list. If it is not on this list, the agent does not go hunting through your whole life.
Constraints. Timebox, tone, language, what to skip. “Do not open personal mail.” “Stop after 40 minutes.” “Draft in English.” “If a source is missing, log the gap. Do not invent the missing file.”
Deliverable. The exact artifacts and where they go. Path, filename pattern, format. “ops/YYYY-MM-DD/brief.md, form-draft.pdf, action-log.md.” If you cannot point at it, it is not a deliverable.
Review point. Where a human is still in the loop. “I read the brief before anything leaves the machine.” “I submit the form.” “I send the chases.” The review point is a door, not a vibe.
Here is Owen’s charter in the same five fields, filled in so you can steal the skeleton, not the business.
Outcome: a review-ready weekly residue pack exists by Sunday night.
Sources: the partners@ inbox, the /partners/forms folder, the chase list in ops/people.md.
Constraints: no personal mail, no sending, no submitting, no deleting. Forty-minute cap. Log gaps instead of guessing.
Deliverable: dated folder with brief, unsubmitted form draft, action log.
Review point: you open the folder Monday morning before any outbound action.
That charter should survive a month. What changes day to day is the brief: “This week the form has a new field for headcount. The chase list added Mira. Ignore the bounce from last Thursday.”
If you rewrite the charter because Mira appeared, you do not have a company. You have a mood.
Then the fences. A fence is a verb the agent may not finish without approval. Put them in a list the runtime can actually enforce, not in a paragraph the model can “interpret.”
Send. No mail, no DM, no comment on a ticket, no “quick ping” from the agent’s own address.
Spend. No checkout, no invoice pay, no upgrade, no adding a seat.
Publish. No post, no go-live, no customer-facing page, no “just update the bio.”
Delete. No trash, no archive-as-delete, no overwrite of the only copy.
Legal. No contract accept, no signature, no policy change, no sending anything that looks like advice you would want a lawyer to see.
Send. Spend. Publish. Delete. Legal. Five verbs GPT-6 Astra does not finish without you.
Everything in that list routes to an approval desk: a pending folder, a queue, or a message that includes the artifact and waits. The employee prepares. You permit.
People skip fences to keep the lid shut. That is how a polite agent mails the wrong thread or publishes a name you were not ready to share.
GPT-6 Astra is strong enough to take those actions if you hand it the tools. Strength is not permission.
The engine proposes. The fence decides.
When the agent fails, first ask whether the brief was bad, the sources moved, or a fence was missing. Only then touch the contract.
Step 3 · Give tools and logins once
An employee with no tools is a narrator. An employee with your whole machine and no map is a hazard.
GPT-6 Astra in a chat box is still you, typing. You want the middle: a shared environment, granted once, boring on purpose.
Your homemade agents should live in one place. A folder on a laptop is enough for the first hire.
A VPS is better when you want the roster to work while the lid is shut for real. A cloud computer is useful when the job needs a persistent desktop, a real browser profile, and files that do not vanish when a tab dies.
Pick one. Do not split the company across five vendor chat boxes.
Five chat windows is not a company. It is five tabs with a shared folder.
The environment is the office. GPT-6 Astra is the brain you put in every desk.
Give the office a small, explicit toolkit.
Files. The workspace, the memory folder, the deliverable paths. Read and write here. Not across the whole disk.
Browser. For the sites in the charter’s source list. Logged-in sessions you created. No surprise domains.
Mailbox. One working inbox the agents are allowed to read. Drafts land in a drafts folder. Sending stays fenced.
APIs. CRM, storage, issue tracker, whatever the job already uses. Keys live in the runtime environment, not in the agent’s memory notes.
Logins happen once, by you. Sign into the browser profile, drop keys into the secret store, confirm the mailbox. After that, agents reuse the office.
There is a short list of things that still need a human in the room. Write it down so the roster does not pretend otherwise.
Passwords you will not store in an agent file.
2FA prompts and hardware keys.
Captchas and “prove you are human” walls.
Payments, even small ones.
Sites that are legally or contractually human-only: banking, admin consoles, anything where a bot ToS is not a debate you want to have.
When the agent hits that list, it stops and writes the blocker into the action log. “Need you for 2FA on the partner portal.” That is a good employee. A workaround around your bank is not ambitious. It is off the charter.
They share the office and the toolbelt. They do not share a personality. Each agent gets its own role file and memory folder.
Do the office once. A sloppy setup shows up later as five half-broken logins and a founder typing passwords for a living.
Then rerun Step 1. Same Owen, same pack, now able to see the inbox without you pasting screenshots. The lid test should feel quieter.
Step 4 · Put GPT-6 Astra behind every agent
This is the center of the playbook.
Every homemade agent in the roster thinks with one engine: GPT-6 Astra. Not a mix of “this one for writing, that one for browsing, a third one because a blog said so.” One brain. Many employees.
16
The interesting part here isn’t really the “10 agents.”
It’s the architecture behind them.
Most people think adding more agents automatically means better output. Usually it just means more calls, more duplicated work, and more places for context to drift.
The coordinator → specialist → reviewer pattern makes much more sense. Give each agent one clear job, keep the shared state clean, and have a separate agent whose only job is to challenge the output.
I especially like the approval layer.
Research, analysis, drafts and prepared outreach can happen while you’re offline. But sending, publishing, spending or deploying still waits for a human.
That distinction is important because automation isn’t valuable just because it removes humans. It’s valuable when it removes the repetitive work while keeping humans at the decisions that actually matter.
And the LEDGER agent is probably the most underrated idea here.
If every completed stage records what was decided, why it was decided and what was rejected, the system can actually compound instead of relearning the same things every week.
I’d honestly start with 3 agents, not 10.
Coordinator → specialist → reviewer.
Then only add another agent when there’s a genuinely separate workflow to own.
12
I think the biggest mistake people make with Jev is treating it like a cheaper LLM.
That misses the actual point.
The interesting part is separating thinking from deciding.
Let the frontier model research, plan and write. Let Jev handle the repetitive judgments: route this, score that, escalate this, approve that. Then let code actually execute the decision.
That architecture makes a lot more sense than throwing an expensive model at every fork in an agent.
The “smart if statement” framing from this article is probably the simplest way to understand it.
What I also like is the discipline around when not to use it.
If code can calculate it exactly, use code. If you need prose, use an LLM. If the decision is genuinely open-ended, use a frontier model. Jev sits in the middle where the decision is bounded but still requires judgment.
The other interesting bit is that multiple questions can be evaluated in parallel, so you can ask for several decisions over the same state without paying the usual latency penalty.
Useful resources from the article:
Jev docs/cookbook
Jev “jaggedness” / failure modes
Jev engineering architecture
The real opportunity isn't replacing LLMs.
It’s deciding where you shouldn't need one.
Jev is the FASTEST AI model ever built for AI Agents
It decides what happens next in milliseconds, at almost zero cost
Most builders will use it in the wrong places
In this article, I show you when to use it and when not to
Full setup:
11
Nandini Shukla retweeted
Netflix replaced their 15 years old recommendation algorithm with an LLM.
It’s called "GenRec" and it completely changes how recommendation algorithms are built.
For over a decade, the Netflix recommendation engine was a masterclass in feature engineering. Data scientists built thousands of complex, handcrafted features to figure out what you wanted to watch next.
It required bespoke architectures. Massive infrastructure. Constant manual tuning.
Netflix threw all of it away.
They built GenRec, an LLM-backed ranker.
Instead of translating your behavior into complex math, they just turn your watch history and metadata into a natural language sentence.
They feed that raw text into a foundation LLM.
The AI simply reads your behavior like a story, understands your evolving tastes, and scores the entire catalog in a single forward pass.
No manual feature engineering. No complex bespoke architectures.
Here is the part that should terrify traditional data scientists.
This text-based LLM didn't just match the highly tuned production system Netflix spent years perfecting.
It beat it.
And it achieved those statistically significant gains using roughly 40x fewer labeled training examples.
We are watching a massive paradigm shift in real time.
The most complex predictive algorithms in the world are being replaced by models that just know how to read.
If Netflix can replace their core product engine with an LLM, what complex system in your business is about to become obsolete?
The interesting part here isn’t really “Netflix replaced its recommendation algorithm with an LLM.”
It’s the change in how we represent the problem.
For years, recommendation systems were built around turning user behaviour into thousands of carefully engineered features, then building increasingly complex systems around those features.
GenRec basically asks: what if we just give the model the behaviour as context and let it reason over it?
That shift is bigger than recommendation systems.
We’ve spent years building pipelines that translate messy human behaviour into structured signals because traditional models needed the data presented in a very specific way.
Foundation models changed that constraint.
Instead of asking, “How do we engineer the perfect features?”
You can start asking, “What if the model can understand the raw information directly?”
The 40x fewer labelled examples is probably the most interesting part to me because that changes the economics of building these systems too.
And I think this is where a lot of companies will get caught.
They have years of infrastructure built around feature engineering, classifiers, rules and bespoke pipelines. The question isn’t whether AI can replace each component individually.
It’s whether the entire abstraction they built around the problem is becoming unnecessary.
That’s a much bigger shift than simply adding an LLM to the stack.
Netflix replaced their 15 years old recommendation algorithm with an LLM.
It’s called "GenRec" and it completely changes how recommendation algorithms are built.
For over a decade, the Netflix recommendation engine was a masterclass in feature engineering. Data scientists built thousands of complex, handcrafted features to figure out what you wanted to watch next.
It required bespoke architectures. Massive infrastructure. Constant manual tuning.
Netflix threw all of it away.
They built GenRec, an LLM-backed ranker.
Instead of translating your behavior into complex math, they just turn your watch history and metadata into a natural language sentence.
They feed that raw text into a foundation LLM.
The AI simply reads your behavior like a story, understands your evolving tastes, and scores the entire catalog in a single forward pass.
No manual feature engineering. No complex bespoke architectures.
Here is the part that should terrify traditional data scientists.
This text-based LLM didn't just match the highly tuned production system Netflix spent years perfecting.
It beat it.
And it achieved those statistically significant gains using roughly 40x fewer labeled training examples.
We are watching a massive paradigm shift in real time.
The most complex predictive algorithms in the world are being replaced by models that just know how to read.
If Netflix can replace their core product engine with an LLM, what complex system in your business is about to become obsolete?
8
This is a much better way to think about using multiple models inside Claude Code.
Most people just throw the strongest model at every step.
Plan? Opus.
Code? Opus.
Debug? Opus.
Review? Opus.
You’re basically paying the premium price for every single decision.
The advisor setup flips that.
Let Opus 5.5 do the actual work, while Fable 5.1 only gets called when another perspective can materially change the outcome: before a big plan, when an error keeps repeating, and before declaring the task finished.
That’s the same architecture I find interesting with Jev.
Expensive model → execution
Cheaper model → decision/check
Code → guardrails
The goal isn’t to have more models running. It’s to make sure each model is being used where it adds the most value.
And this fits nicely with Claude Code’s broader setup too. Subagents can handle separate roles, while CLAUDE.md keeps the project context consistent across sessions.
Useful resources from this setup:
Claude Code Advisor: code.claude.com/docs/en/advi…
Claude Code docs: code.claude.com/docs/
I’d honestly test this on one real workflow before adding a dozen agents. The architecture matters more than the number of models.
11
This is probably one of the more interesting ways to think about model orchestration.
Most people still use their best model for everything.
Plan? Opus.
Code? Opus.
Debug? Opus.
Review? Opus.
Which is basically paying the highest possible price for every decision.
The advisor pattern makes more sense. Let Opus actually do the work, then bring in another model only at the points where a second opinion can change the outcome.
Before a big plan.
When the same error keeps coming back.
Before calling the task finished.
That’s a much better use of model capacity than having two expensive models constantly doing the same work.
And I like how this maps to the Jev architecture too. The expensive model handles the actual execution while a cheaper decision layer gets called only when there’s uncertainty or a decision worth checking.
The interesting part isn't “Opus + Fable.”
It’s the architecture:
Strong model → execution
Cheap model → decision/check
Code → guardrails
That’s probably where agent stacks are heading.
Also, this is worth playing with directly:
code.claude.com/docs/en/advi…
The setup prompt in the post is probably the easiest way to test the workflow without rebuilding your whole Claude Code setup.
Claude Code tip: once Opus 5.5 is your main model, stop letting your Fable 5.1 quota go to waste
put it on call with /advisor
run /advisor fable
Opus 5.5 keeps doing the work
Fable 5.1 sits on the sidelines, reads the whole session, and steps in at three moments:
→ before a plan: is this right?
→ when the same error comes back: am I going the wrong way?
→ before "done": did I miss anything?
Fable 5.1 advises. Opus 5.5 writes the code
the same idea sits under Jev engineering: the expensive model stops weighing in on every step and only gets called at the moments that change the outcome
• the full setup
> Opus 5.5 on high runs the main session
> subagent one reads code
> subagent two edits and runs tests
> subagent three looks up docs
> all three on medium
> Fable 5.1 on call
hand the tree and this prompt to Claude Code 👇
"Set up my Claude Code to match this tree:
1. Reuse fitting subagents from ~/.claude/agents and .claude/agents.
> Propose new ones only for missing roles
> Set each to model: opus, effort: medium
> Leave any that set a different model alone and list them
2. Set main session effort to high via effortLevel in ~/.claude/settings.json
3. Check for env vars that disable the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, anything that stops flag fetching) and CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, don't change them
4. Add a rule to ~/.claude/CLAUDE.md: ask the advisor before a big plan, when an error repeats, and before calling a long task done
Show me the changes first. Don't edit files yet."
↳ code.claude.com/docs/en/advi…
6
I think most people are still looking at Claude Code as “ChatGPT but for coding.”
That’s probably the least interesting way to use it.
The real shift is that Claude Code can actually operate inside your project. It reads the files, makes changes, runs commands, checks the output, and keeps iterating until the task is done. That explore → plan → execute → verify loop is what makes it feel fundamentally different from a normal chat interface.
And once you understand that, the interesting part isn’t even coding.
You can use the same system for content workflows, research, docs, data, automations, internal tools, basically anything that lives inside files and repeatable processes.
The CLAUDE.md idea is also underrated. Instead of explaining the same context every single time, you create a project-level instruction file with your conventions, commands and rules. Then Claude starts every session with that context.
Then you add skills, subagents, hooks and MCP when you actually need them.
That’s where Claude Code stops being an AI assistant and starts becoming infrastructure for how you work.
The biggest mistake is trying to learn every feature.
Pick one real workflow, make Claude own more of it, and build from there.
12
Most people are still thinking about Jev as just another AI model.
The more interesting way to look at it is as a decision layer.
You give it state + a specific question, and it gives you a structured answer with a probability.
That sounds simple, but you can build a lot around that.
Model routing.
Command safety.
Context pruning.
Trading signals.
Support ticket routing.
CV screening.
Moderation.
SEO audits.
The common pattern is always the same:
Your code or another model collects the information → Jev makes the decision → code actually does the work.
And that separation is important.
You don’t want Jev calculating dates, sizing trades or deciding hard limits. Those things belong in code. Jev should make the judgment call, and your system should decide what to do with that judgment.
The part I like most in this guide is that it actually shows working repos instead of just talking about the model.
Especially the trading and Claude Code examples.
The bigger opportunity here isn’t building another chatbot.
It’s finding the repetitive decisions in a workflow that are currently being handled by an expensive LLM and replacing those calls with a cheap, structured decision layer.
That’s where Jev gets interesting.
12
I still think most people are looking at Jev the wrong way.
They’re thinking “another AI model.”
It’s not really competing with Opus, Sonnet, GPT or Gemini.
The interesting part is that Jev can sit between your agent and those models and handle all the small decisions that don’t need a frontier LLM.
Which tool should I use?
Is this command safe?
Should I retry?
Which model should handle this?
Should I keep this context?
Most agents are wasting expensive model calls on these decisions.
That’s where Jev gets interesting.
You let Jev handle the fast, structured decisions and only send the genuinely hard stuff to the bigger model.
And because the output is typed with probabilities, your software can actually make decisions from it instead of trying to parse another paragraph of LLM output.
Model routing, context pruning, command safety, intent classification.
These sound like small things individually.
But an agent makes hundreds of these decisions over a long workflow.
That’s where the cost and latency start adding up.
Jev isn’t replacing the brain.
It’s becoming the decision layer around the brain.
5
This is probably one of the better ways to actually use multiple models in Claude Code.
Most people think the answer is just using the smartest model for everything and cranking the effort to max.
But that gets expensive and sometimes makes the agent overthink simple decisions.
I like this setup because every model has a specific job.
Opus handles the main work and owns the context.
Fable acts like a senior engineer looking over its shoulder, but only when it actually matters: before a big plan, when the same error keeps coming back, and before the agent calls the task finished.
And Jev handles the tiny decisions that don’t need expensive reasoning.
Which file should I inspect? Should I retry? Which tool should I use?
That separation is what makes this interesting.
You’re not just adding more models.
You’re building a small engineering team where each model handles the part it’s actually good at.
The bigger shift is going to be learning how to orchestrate these models properly instead of asking one model to do everything.
Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle
put it on call with /advisor
run /advisor fable
Opus 5.5 keeps writing the code
Fable 5.1 reads the full session, every tool call included, and only speaks up at three points:
→ before a plan: is this the right approach?
→ when the same error comes back: am I digging in the wrong place?
→ before "done": what did I miss?
Fable 5.1 reviews. Opus 5.5 ships
Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big model only sees the ones that split
- the full tree
> Opus 5.5 on high runs the main session
> explorer reads the code
> worker edits and runs tests
> researcher pulls the docs
> all three on medium
> Fable 5.1 on call as the advisor
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher.
> Draft new ones only for missing roles
> Give each model: opus, effort: medium
> Skip any that pin a different model and list them
2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable
3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing
4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done
Show me every change as a diff first. No edits until I say go."
↳ code.claude.com/docs/en/advi…
6
This is pure fucking treasure.
25 Claude Code plugins + skill packs for a builder stack that actually carries work from idea to the next session.
Planning. Design. Browser work. Databases. QA. Security. Reviews. Telemetry. Memory.
FRAME THE JOB
AgentHub
github.com/alirezarezvani/cl…
Docs Cockpit
github.com/Guohao1020/docs-c…
Context Commit
github.com/KevinVitale/conte…
Pro Workflow
github.com/rohitg00/pro-work…
Agent Nexus
github.com/SentioLabs/agent-…
BUILD THE THING
Browser Use
github.com/browser-use/plugi…
Impeccable
github.com/pbakaus/impeccabl…
Universal Design System
github.com/mkatogui/universa…
Database Operations
github.com/wshobson/agents
Supabase Agent Skills
github.com/supabase/agent-sk…
VERIFY IT
User Testing Agent
github.com/ncklrs/claude-chr…
Mutation Testing
github.com/secondsky/claude-…
Accessibility Testing
github.com/Euricom-IO/euri-a…
GAIA Security
github.com/metraton/gaia
Dual Review
github.com/jmprieur/pr-inbox
RUN THE LOOP
Review Loop
github.com/onsails/skills
Observability Harness
github.com/JoshuaOliphant/cl…
Performance Budgeting
github.com/SSiertsema/claude…
CCAM Analytics
github.com/hoangsonww/Claude…
Docs Manager
github.com/L3DigitalNet/Clau…
KEEP THE KNOWLEDGE
Demarkus Memory
github.com/latebit-io/demark…
Memory Dream
github.com/StartupBros-com/h…
Context Engine
github.com/ArtMin96/forge-st…
Context Canary
github.com/vincentor/claude-…
Docs Cleaner
github.com/daymade/claude-co…
The loop:
Frame the job → build the interface + data layer → test the behavior → inspect risk + performance → preserve the evidence → pick up the next session with context.
The handoff is the useful part.
Each stage should leave something the next stage can inspect, verify and reuse.
That’s how you turn a bunch of AI tools into an actual workflow.
6
This is actually solving a problem I think a lot of agent builders are going to run into.
Just because an agent has a skill doesn’t mean the skill is useful.
The ablation testing is probably the most interesting part. Run the same task with and without the skill and see if it actually improves the outcome.
That’s a much better way to evaluate agent skills than looking at one successful demo and calling it a win.
Also like the separate activation scoring. A skill not being used and a skill being used badly are two completely different problems.
Feels like the kind of tooling agents need as they move from demos to actual production workflows.
A skill that works once isn’t necessarily helping your agent.
Caliper is an open-source evaluation tool for builders who want to test agent skills with Claude Code, Codex, Pi, or Hermes.
It helps you measure whether a skill earns its context by running it repeatedly in a real agent, then comparing the results with the same skill removed.
Key features:
• Repeated real-agent runs – run each task k times to track a skill’s success rate
• Separate activation scoring – see whether the agent chose the skill separately from whether the task succeeded
• Skill ablations – rerun the same tasks without a skill to measure what it adds over the bare agent
• Neighbour-skill tests – declare competing skills and assert which one should handle a prompt
• Task-level comparisons – diff full and ablated runs task by task, including token use and wall time
It’s open-source (MIT license).
Link in the reply 👇
7
This is actually a solid breakdown.
Most people look at AI and immediately ask, “What tool should I use?”
I think the better question is, “What can I stop doing manually now?”
That shift is pretty important.
The real leverage isn’t just using AI to write an email or summarize something. It’s rebuilding parts of your workflow around what AI can now do.
And honestly, we’re still pretty early here.
A lot of teams are still experimenting with AI while a few people are already building entire workflows around it.
The gap is going to get pretty big between people who just use AI and people who actually redesign how they work around it.
Good stuff.
6
I don't think NVIDIA paid $12.93 billion for Hugging Face.
Earlier this month, NVIDIA agreed to buy Hugging Face, and it's a big deal because Hugging Face is the platform where people find, share, test and deploy open AI models. Most of the posts I saw about it stopped at the price tag. But if you're trying to build a career in AI, the price is the least useful part of this story. The better question is why NVIDIA wanted this company at all.
Here's how I see it.
1.NVIDIA isn't just a chip company anymore.
It already has the GPUs, CUDA, the networking and the infrastructure that most of AI runs on. What it didn't have was a place where developers actually spend their day. Hugging Face is that place, with more than 18 million developers, researchers and creators, and over 3 million models, 500,000 datasets and a million apps.
2.That's what the money really bought.
Not just the models or the technology, but the community around them. With this deal, NVIDIA reaches from the bottom of the AI stack all the way up to where people decide what to build with.
3.AI is a much bigger field than most students think.
The path most people picture is learning Python, building a chatbot and landing an AI job. But this one deal touches compute, open models, datasets, deployment, developer tools and security all at once. There's room for very different kinds of people in that, and you don't have to be an ML researcher to find your place.
4.Read the strategy, not just the headline.
When a deal like this lands, it's worth asking a few questions before you scroll past. Why this company, and why now? What does it add that the buyer didn't already have? Which part of the AI stack does it give them more control over? And what does that tell us about where the industry is heading?
Those questions will teach you more about how AI works as an industry than most courses will.
NVIDIA has said Hugging Face will stay open, that you won't need NVIDIA hardware to build on it, and that it will keep supporting models from every builder. I hope that holds. But I keep wondering: when one company owns both the chips and the place where open AI lives, how open can it really stay?
If you want honest breakdowns of the AI tools actually worth your time, follow me here and across all my channels.
Instagram , YouTube , Facebook, LinkedIn: @tech_with_nandini – at Toronto, Ontario
7































