Ultimate Claude Tutorial: How to Use Claude AI for Beginners | Become a PRO!

Guide To Using AI Most Effectively
13 followers
3 Video Views·Sep 30, 2026
Anthropic just shipped Claude Fable 5.1 — and I put it through real prompts instead of just reading the benchmark charts. In this video I break down every meaningful new feature in Claude Fable 5.1, what actually changed vs the original Fable 5, and whether it's worth switching for your workflow.
AI Generated·May contain errors
Everything you're watching right now
came out of one prompt in Claude Fable 5.1,
because it runs with no ready-made libraries
and no second attempt.
The new model from Anthropic is already out.
People are calling it the most powerful model
for the hardest work you can throw at it.
So today, I'm putting it in front of real prompts
and we'll see what actually holds up.
Then at the end, I've got seven tips
for getting more out of it and paying less while you do.
Anthropic built this one for the long stuff.
Code-in sessions that run for hours,
piles of documents, research that takes a dozen steps
before it gets anywhere.
The unusual part is their own advice about it,
because they tell you not to reach for it by default.
For most normal tasks, they point you at Opus 5
and they say Fable 5.1 for the cases
where you genuinely need maximum power
on something complex and multi-step.
That's a strange thing for a company to say
about its most expensive model.
It's also the most useful line in the whole announcement.
The price per token didn't move,
$10 per million tokens going in,
50 per million coming out,
and a token is basically a chunk of a word.
What changed is the cheap part.
When the model re-reads material it has already seen,
that now costs 75% less, down to 25 cents per million,
Anthropic says this pulls the cost of a typical task
down by roughly a quarter,
and for heavy multi-step work by almost half.
That's their number, not mine.
Independent tests don't always land in the same place.
The rest of the spec sheet is big
in a way that's hard to feel.
It holds about a million tokens of context,
which in plain language means you can throw
an enormous pile of material at it
before it starts losing the thread,
and it can write back up to 128,000 tokens in one go.
It reads text and images and it thinks before it answers,
instead of blurting out the first thing that comes to mind.
Anthropic lists six places where they say it improved.
Long coding sessions, documents and spreadsheets and slides,
multi-step research, reading charts and diagrams,
using that huge context reliably,
and driving interfaces on its own.
That's a lot of claims.
Tests are cheaper than arguments.
One more thing before we start,
and it matters if you've ever been refused
for no good reason.
Anthropic says the model now falsely blocks
around 60% fewer cybersecurity questions
and around 85% fewer harmless biology
and medicine questions.
The actual limits didn't disappear.
Real penetration testing, exploit writing,
and serious biological research
still get pushed somewhere else.
So it's less jumpy, not more permissive.
Let's check how agentic this model's thinking actually is.
And I picked a task with more moving parts
than a person can hold in their head at once.
Seven days in Japan for two people,
$3,000 for everything including the flights,
and the two travelers want opposite trips.
One is going for anime,
the other wants forests and silence.
On top of that,
it has to pull real flight options for October,
shortlist three hotels,
and lay out an hour-by-hour route
that keeps both of them happy.
I turn thinking mode on before I send it,
so you can watch it work the problem
instead of just reading the finished plan.
This is the line where a chatbot
and something closer to an agent separate.
A chatbot hands you a beautiful itinerary
with plausible sounding numbers attached.
What I want to see is the arithmetic holding up,
whether $3,000 still covers two flights
after it picks those hotels,
and whether it says a price is an estimate
instead of inventing a booking that doesn't exist.
Then there's the human part.
The weak answer alternates one anime day
with one quiet day and calls that balance.
A good one fixes the geography first,
so nobody burns four hours on a train being polite.
And here's what came back.
The budget holds.
Flights, three hotels, food, and local trains
all fit under $3,000,
and it marks the flight prices as estimates
instead of pretending it booked something.
That's the honest move.
The route is grouped by geography as well.
The anime days sit together at the start in Tokyo.
Then both of them head out to the mountains
for the quiet half,
so nobody burns four hours on a train being polite.
The hour-by-hour timing is optimistic in a couple of places
about how fast you cross a city that size,
but the thinking underneath it is right.
It solved the constraints first and wrote the plan second,
and that's exactly the behavior I wanted out of this one.
That trip prompt is exactly why
I never trust one model on its own.
You only see how good an answer is
when another one sits next to it.
Running four subscriptions for that is expensive,
so I do it in my own platform, AI Master.
One window, one login,
Claude, ChatGBT, Grok, and Gemini side by side,
and cheaper per token
than paying for each of them separately.
The chat is one piece of it.
Images, voice, and video generate in the same place,
also cheaper, and you can keep one character
who looks identical across every generation.
That character can be published
and earn money for you right there.
Whatever you make gets shared into the feed
so it works for your reach.
Bearable runs a full channel with your team and AI agents
writing scripts and descriptions,
editing video and images, and building thumbnails.
The academy holds over 200 lessons, roughly 30 hours.
On the site, you'll see real results and cases,
screenshots and demo videos
of people saying what it did for them.
More than 15,000 people are in the community already.
The path is short, and I'll click it on screen.
You go to amaster.me and take the annual subscription.
That's the one I tell you to get
since the discount sits there.
Then you're inside the account.
Seven days to take your money back if it isn't for you.
That's my stack.
Now back to Fable 5.1.
Let's check the visual side of Fable 5.1.
Reading a clean screenshot is one thing,
but reading my own handwriting
is a different test entirely.
I sketch a basic app flow on a sheet of paper.
Login, home, product, card, checkout.
I draw it messy, on purpose.
The boxes don't line up, and arrows cross each other.
One screen ends up cramped into the corner
because I ran out of room.
I photograph the paper with my phone
and drop it straight into the chat.
The ask is three things.
Turn the scribble into a clean flow,
catch anything that breaks along the way,
and tell me what step is missing.
Reading it is only the first job.
Any model can transcribe rough handwriting by now,
and most stop right there,
handing back a tidy copy of your own drawing.
I want the layer above that.
It has to work out which arrow connects to which box
when the lines overlap.
Then it has to flag anything about the flow itself
that doesn't actually make sense as an app.
That's the part models usually dodge,
because pointing at a hole in someone's logic
is riskier than just copying it.
And it reads all of it correctly.
Every box from the paper lands in the right place,
with the arrows sorted out even where two of them cross.
It also catches real gaps in the flow.
After the user hits pay, there's nowhere to go.
No order confirmation and no clear next step.
Checkout has no way back to the card either.
It flags those as problems in the flow,
not mistakes in my drawing.
Then it builds a second, improved version,
and adds the steps I hadn't drawn at all,
including a failed payment state and an order confirmation.
That's the useful part.
Reading the mess was just the entry fee.
If you're running a business
and juggling 10 different tools right now,
what if I told you that one platform
could replace all of them?
This is GoHighLevel.
You get access to pretty much all the features.
Social Media Planner.
You can schedule posts, see your content calendar,
and even repost content across multiple platforms
with one click.
Email Marketing.
GoHighLevel has a full email suite.
You can create campaigns, build email templates
with a drag and drop editor.
GoHighLevel has a built-in calendar and booking system.
This replaces tools like Calendly.
You can create different calendar types,
one-on-one meetings, group calls, round-robin scheduling,
if you have a team.
And here's the best part.
GoHighLevel has a ton of pre-built workflow templates.
I've linked a 30-day free trial in the description,
not the standard 14 days, an exclusive extended trial.
Fable 5.1 can now do end-to-end 3D modeling,
and it does that through code instead of a modeling program.
So let's test it on something
where the model has almost nothing to work with,
except the layout.
Instead of describing the finished scene in words,
I give it a 2D top-down floor plan
of a medieval castle room.
There's a fireplace on one wall, windows on both sides,
a long dining table in the middle,
columns, a raised platform, and a throne,
all drawn as simple shapes and labels
seen straight from above.
No image of the finished room, no perspective,
just a flat plan.
Then I ask for three fully built 3D versions
of that exact same layout.
Gothic, Abandoned, and Royal.
All three have to run interactively inside an artifact.
Three variants, one flat drawing.
There's a lot hiding in that request.
The floor plan tells it where things go,
but almost nothing about what they look like
in three dimensions.
The model has to decide how high the walls are,
how deep the windows sit, how tall the columns should be,
and how the fireplace and raised platform
actually fit into the room.
Even the furniture has to land at the right scale,
instead of looking like a dollhouse
or floating above the floor.
And then it has to do all of that three times,
holding the same floor plan steady
while changing the materials, condition,
and lighting enough that the rooms actually feel different,
not the same castle under a different filter.
And here's what it built.
All three versions follow the plan.
The fireplace, windows, table, columns, throne,
and raised platform stay where I drew them.
And the room reads at a believable scale
instead of feeling generated around the camera.
The Gothic version is dark and heavy
with aged stone, old wood, and warm firelight.
The Abandoned version keeps the same room,
but lets it fall apart with cracked surfaces,
damaged furniture, dust,
and colder light coming through the windows.
The Royal version restores it with cleaner stone,
polished wood, tapestries, and warmer lighting.
And switching between them makes the important part obvious.
The geometry doesn't move.
It's still the same room underneath all three.
That's the part I was worried about walking in,
a model that understands the vocabulary of a style,
but loses the actual plan while applying it.
This one kept both.
Test four checks pure coding with no crutches allowed.
I put a hard constraint on the model
and ban every outside graphics library.
The task is to build a Northern Lights simulator
from scratch in plain JavaScript,
running interactively inside an artifact in the chat.
Add three working sliders, movement speed,
color brightness, and star density.
One prompt, one attempt, no help.
That last line is the whole test
with no library, nothing is handed to it.
The model has to work out
how a curtain of light bends and drifts
and how the color fades into the dark
instead of stopping on a hard line.
Stars are their own problem
because scattered badly they read as a grid
instead of a sky.
Real aurora is slow and uneven.
It brightens in one place while it fades in another
and it never loops like a screensaver.
Then there are the sliders,
which sound like a small detail and aren't.
Speed should change the motion and leave the color alone.
Intensity has to change brightness
without freezing the drift.
When a model only half understands its own code,
the sliders are where that shows.
And here's what it drew.
The sky moves the way the real thing moves.
The curtains drift unevenly.
One part brightens while another fades
and the edges bleed into the dark
instead of ending on a line.
The stars sit scattered with no grid showing through them.
The sliders are the part I expected to break and they don't.
I push all three to both extremes
while the scene is animating
because the middle always looks fine
and each one only touches what it's supposed to.
Speed changes the drift and leaves the color alone.
Star density adds stars instead of repainting the sky.
At maximum density it does stutter
and that's the one place the whole thing slips.
Written from nothing in a single attempt,
this is the closest any of these tests gets to real work.
Test five is a full first-person shooter
and it has to appear inside the artifacts window
from a single prompt.
The theme is an alien invasion.
The player stands in a neon arena on a space station
with a blaster and a crosshair on screen.
You walk with WSD and look around with the mouse.
Left click fires the laser.
The enemies are flying saucers and tentacle creatures
built out of spheres and cylinders
with a neon green or violet glow
and they hunt you across the arena.
On top of that, I want waves that get harder,
a health bar, an overheat gauge on the blaster
and a counter for kills.
One prompt, one attempt and it has to run.
Almost none of that is drawing.
The mouse look has to grab the cursor and stay smooth
or the thing feels broken in the first two seconds.
The aliens have no model to download
so their bodies come out of a handful of primitives
that still have to read as a creature
instead of a pile of balls.
Then they have to hunt,
which means every saucer tracks the player each frame
without sliding through a wall.
The overheat gauge is the sneaky one.
It only means anything if holding the trigger too long
actually cuts the laser and makes you wait
and the waves have to climb
without turning round two into a brick wall.
And here's what it built.
The arena renders, the mouse look holds steady
and the saucers come in waves that get thicker every round.
The kill counter climbs as you drop them.
The overheat bar fills while you hold the trigger
and shuts the laser down until it cools,
which is the mechanic I expected it to skip entirely.
Health drops when something reaches you.
The rough parts are the ones you'd guess.
Alien bodies read as spheres with tentacles glued on
and the enemies barely collide with each other
so they stack into the same spot.
Frame rate sags once the light waves fill the arena.
Still playable out of one paragraph of text.
That's the testing done.
Now the practical part,
which is the stuff I'd want somebody to tell me
before I started running this thing every day.
Seven tips.
The first four work anywhere you talk to Claude.
In the normal chat window,
no setup involved.
The last three are for people who live inside Claude Code
and I'll say so when we get there.
Start with the effort level and turn it down instead of up.
This is the setting people get wrong on day one
because maximum sounds like better.
Code Rabbit ran the same review both ways
and low effort caught more problems than high effort did.
61% against 57.
It also finished almost three minutes faster.
My own runs came out the same way,
better and quicker on low every time I lined them up.
So start low, raise it only when the output
gives you an actual reason to
and most of the time it won't.
The next one saves you from a habit
that shows up on every long job.
Tell it that nobody is watching.
Out of the box it behaves
like there's a person sitting next to it
so halfway through a long job,
it stops and asks permission
for a step your original request already covered.
Write the fix straight into the prompt.
Say there's no one here and that it should keep going
through everything the request covers
as long as the action can be undone.
It stops asking questions it never needed to ask.
That doesn't cure the drift on very long sessions
and it still writes code that runs fine
while quietly doing the wrong thing.
You read the output at the end regardless.
This next one matters most when the job is big and ugly.
Give it the whole thing at once.
Look at what Anthropic chose to show off with this model.
It wasn't a coding demo.
They ran it across decades old radar data
from the Magellan mission to Venus
and let it work the analysis all the way through.
That tells you where it earns its money.
On the hardest task in my own testing,
it finished about 40% faster than Fable 5
and cost meaningfully less getting there.
On simple work, the old model did better.
So don't chop a feature into eight little prompts.
Describe the finished result you want
and let it run to the end on its own.
The last one that works anywhere is about how it writes.
Ask it to drop the mannered prose.
Fable 5.1 reaches for fancy metaphors less than Opus 5
and the old Fable 5 did, so you get fewer lines
about levers worth pulling
when the honest version is changed to setting.
The habit isn't gone though.
Sentences also come out longer now
with fewer breaks between paragraphs,
which makes a long answer harder to read
than it needs to be.
One line in your prompt fixes both at once.
Ask it to drop all mannered prose.
That's the exact phrase I use
and the writing comes back plain.
Now the same logic, but for Claude code specifically
and it starts with a cleanup job.
Delete the instructions you wrote for the old model.
Every rule you added to patch the behavior of Fable 5
or something older than that is still sitting
in your Claude.md right now.
The new model reads all of it
and burns effort fixing problems it doesn't have anymore.
Testing that is easy.
Pull one instruction out, run the same task
and if nothing changes, that line was dead weight.
There's also a terminal command,
Claude API prompt audit,
that goes looking for the stale ones
and suggests specific edits.
It only suggests, it never touches your files by itself.
The next one comes out of the same over helpfulness.
Name what it isn't allowed to touch.
This model has a habit of doing more than you asked.
You request one feature and while it's in there,
it decides to tidy up something next door.
I asked for a feature once
and it went and rewrote my test files
which nobody had mentioned at any point.
So list the things that stay untouched
right there in the prompt and add one more line.
If it notices another problem,
it mentions that at the end
instead of fixing it on its own initiative.
You get the fix you asked for and a note about the rest.
And the last one shows up straight on your bill.
Make it edit the file instead of rewriting it.
Left alone, it will regenerate an entire file
when the actual change is four lines.
Same result and you pay for every one
of those output tokens on the way out.
So tell it to edit only the part that needs editing
whenever that gets you the same thing.
On one small script, nobody notices the difference.
On a project with a few hundred files,
it turns into real money
and it's one sentence in your prompt.
Two smaller money things while you're setting all this up.
The cheaper rereading only counts
inside the same conversation.
So if you drop a big document in
and then open a fresh chat for every follow-up question,
you pay full price each time
and your bill looks nothing like the announcement.
Keep one long thread instead
and treat that million token window
as a ceiling rather than a promise
because the further a piece of material
sits from your question,
the more likely it gets skimmed.
Put what matters right next to the question
and the number stops mattering much.
One last piece of honesty about the tests you just watched.
Every one of them was a single prompt and a single attempt
because that's the only fair way
to see what it can actually do without a safety net.
Nobody actually works like that.
In real use, you correct it.
Rerun the broken part and push it toward what you meant
and that's where it's strongest.
My verdict after five tests.
Fable 5.1 is a real step up
and the tests that moved me weren't the flashy ones.
Reading a floor plan correctly
and building a moving scene from nothing
with no libraries to lean on
is the part that changes
what I'd actually hand it on a Monday morning.
What annoys me is the pricing logic.
You pay top rates for a model
whose own maker tells you
not to reach for it most of the time
and working out which side of that line your task falls on
is left entirely to you.
If you want to run a prompt against Claude,
ChatGPT, Gemini and Grok side by side in one window,
that's what I built AI Master for and the link is below.
See you in the next one.
