# 12 Claude Prompts We Actually Ran on Opus 5.5 and Claude Code, With the Results

> Twelve prompts we ran on Claude Opus 5.5, word for word, with what each one produced, what the big builds cost, and the prompt habits our 27-run test showed you can drop.

By Pat Simmons · November 2, 2026 · 12 min read

Canonical: https://www.aiformortals.co/blog/claude-prompts

The Claude prompts that work are short and specific. Tell Claude the facts only you know, the format you want, who the answer is for and what to leave out. In our 27-run test of long vs short Claude prompts on Claude Opus 5.5, we cut three everyday work prompts from about 190 words to between 20 and 40, and every run still got the main answers right, hidden traps included. Expert personas, "think step by step," all-caps CRITICAL warnings and an offer of a $200 tip made no difference we could measure.

Below are 12 prompts we ran, word for word, with what each one produced: one for meeting notes, three that built a small invoice app in Claude Code, six that rebuilt the Notability note-taking app as an iPad app, and two big build prompts with what each run cost.

## How do you prompt Claude?

You prompt Claude by writing what you want in a sentence or two, then adding only what Claude can't know without you. In our test, four kinds of lines changed the answer and the rest didn't.

- Facts only you know: your policy, your numbers, today's date, the deadline.

- The format: a word limit, "grouped by person," "just the list."

- Who it's for: "This is going to our CEO, so flag anything in the data that looks off."

- What to leave out: "only give me the email."

Lines that tell Claude how to think (a persona, "take a deep breath," "check your work three times") didn't change whether it got the answer right. Anthropic's own prompting guide for Opus 5.5 suggests removing "think carefully before answering" lines from chat instructions, because the model decides how much to think on its own.

For building software, the same rule holds with more room to talk. The app prompts below read like someone describing a problem to a colleague: who they are, what annoys them, what they want to see, and what to check before calling it done.

## Claude prompts for everyday work: notes, emails, spreadsheets

For everyday work, a one- or two-sentence prompt plus your material did as well as a 190-word prompt full of rules. We tested three jobs with a trap hidden in each: pulling action items from meeting notes where one task gets cancelled, answering an angry customer whose refund depends on a policy detail, and finding the fastest-growing region in a sales sheet with a duplicated row.

This is the trimmed meeting prompt we ran. Every run listed the same seven tasks with the right owners and dates, and none listed the cancelled task.

**1 · Meeting notes to action items**

```
List the action items from this meeting, grouped by person, with deadlines. Today is Wednesday, October 29.

[paste the transcript here]
```

Adding today's date paid off. Claude used it to point out which tasks were already overdue and which one was due that day.

The trimmed customer email prompt did its job with two sentences of instructions, including "Keep it under 150 words and only give me the email." All nine email replies across the three versions offered the full refund and explained why the customer still qualified. The trimmed version answered in about 4 seconds, against about 7 for the long version, with the same email at the end.

The trimmed spreadsheet prompt had one extra line: "This is going to our CEO, so flag anything in the data that looks off." All nine sheet answers caught the repeated row and named the right region, and the trimmed runs read the most like a careful analyst's, starting with the numbers that most needed checking.

This table compares the three versions, averaged over three runs each, from the full test write-up:

Prompt
Words in the prompt
Words in Claude's answer
Seconds

Meeting, long196995
Meeting, trimmed182238
Meeting, bare92095
Email, long1801377
Email, trimmed301414
Email, bare102428
Sheet, long19342419
Sheet, trimmed4034018
Sheet, bare1820910

The meeting answers from the trimmed and bare prompts ran about twice as long as the long version's, because Claude added useful extras like overdue tasks and a short list of what was dropped. The long spreadsheet prompt's "show all of your reasoning" rule made Claude write out every addition, so it took about 19 seconds and 420 words where the bare version took about 10 seconds and 210.

## Claude Code prompts to build your first app

To build a first app in Claude Code, describe your problem in plain English, say what you want to see, and ask Claude to tell you how to open the result. We did that in an empty folder on Claude Opus 5.5, and a working app called Who Owes Me opened in the browser about 90 seconds later. The whole walkthrough is in Claude Code for beginners, step by step.

Claude Code is Anthropic's coding agent, and it works in your terminal, editor and browser. Claude's plan comparison lists it as included on Pro ($20 a month billed monthly) and the plans above it, and not on the Free plan.

**2 · Build the first version**

```
I'm a freelancer and I always forget who still owes me money. I don't know how to code. Can you build me a simple app I can open in my web browser where I can type in a client's name, what the job was, how much they owe, and the date the invoice was due. It should show me everyone who hasn't paid yet, with the ones that are late at the top and how many days late they are. Next to each one I want a button that writes a short, polite reminder email I can copy and paste into Gmail. It needs to remember my list when I close it and open it again. Keep it simple and make it look clean. When you're done, tell me exactly how to open it.
```

_The first version of Who Owes Me, built from the prompt above, with four made-up clients typed in. Late invoices sit at the top with a red edge. Screenshot from our Claude Code beginner test._

One thing went wrong. The reminder email greeted "Hi Northwind," the first word of a bakery's name, because the app only knew the client's company name. The second prompt fixed that by describing the problem the way you'd tell a person, and added three more wishes. All four changes were done about two minutes later.

**3 · React to what you tried**

```
I tried it and it's great, but a few things:
1. The reminder email starts "Hi Northwind," and Northwind is a bakery, not a person. Let me add the name of the person I deal with for each client and use that in the email.
2. Some of my clients pay me in euros or pounds. Let me pick the currency for each invoice, and don't add euros and dollars together in the totals.
3. Copying and pasting into Gmail is a bit fiddly. Can there be a button that opens the email in Gmail already filled in?
4. At the top, show me how much I've been paid this month.
```

For a bigger change, we switched Claude Code to Plan mode, where it can look and explain but can't edit anything. It came back with four options in plain language and picked one: keeping the list in a Google Sheet in your own account.

**4 · Ask before a big change**

```
I'd love to check this list on my phone too, and have the same list there. What are my options? Don't change anything yet, just explain it simply and tell me which one you'd pick.
```

## Prompts that rebuilt a real app with Opus 5.5

Pat rebuilt Notability, the iPad note-taking app, with Claude Opus 5.5 in six prompts, one per phase, each reacting to what the last one produced. The result, called Inkwell, replays your handwriting in sync with the recorded audio, transcribes live and works out who was speaking. The prompts below are exactly as he typed or dictated them, half-finished thoughts included, and you can find every prompt from the Notability rebuild with the install steps in his post.

The first prompt asks Claude to study the real app and write a spec (a plan document the building agent works from) before any code exists.

**5 · Phase 0: research the app and write the spec**

```
But I 1st just wanted you to get a sense of how notability works, so we can build out our own version. So I want the same kind of features, all the different notes. It's a relatively simple app. I guess the hardest part is the actual recording feature, and then being able to When you're recording and taking notes, getting exactly when you're taking notes on that record. So when you play back that record, it will show you exactly the note that you were taking. At the time of the record, if that makes sense.

And then once we get there, what we're gonna do is we're gonna add some AI features onto this. I want this to function. So we're gonna get live transcripts in here. And then we're gonna also add a feature where, and I still haven't really thought through this, where we hand this over to an AI agent.

Don't overcomplicate this. I want this UI to be simple, straightforward. Don't add all of these like, dumb, superfluous things that sometimes you tend to add. It should really be as basic as notability, and then we'll just stack our own features on top of it.
```

The second asks for every screen drawn first, so Pat could change the parts he disliked before they were built.

**6 · Phase 1: mock up every screen**

```
On the actual UX, there's a couple things that I don't like about notability. So, in this 1st phase, you can just note this in the PRD for the build agent. In this 1st phase, I want all of the different app screens, and I'm going to react to those, and I want us to come up with our own variation of looking at their recordings, because I don't like how notability does it. They have some funky UX that I want us to change, especially because we're going to be live transcribing this.

Tell the agent in the PRD to just use its best judgment and then come back to me with some kind of recording output that I can react to in the app screens when we put those together in phase one.
```

**7 · Phase 2: build the real iPad app**

```
Go ahead and just build this out into a proper iOS, or I guess, iPadOS application. So full, all the best practices, do some research on this, just make sure that you're kind of double checking your work, you could even spawn an agent to do this, just in building all of this out. I'm assuming it's going to be react native, but let me know. I just want this to be a functioning application. If it's gonna be more complicated to build in Swift, then you can just avoid that.

And yeah, I mean, QA, do everything, don't stop until this app is live or as close to live on my device as possible.
```

In the video at the top of this page, Pat explains at 20:40 why his prompts leave design calls to the model: "I'm just not an expert in user experience, especially with an iPad app. So I now just defer to Opus 5.5 to make these kinds of decisions. And if it's wrong, I just can react to something visually."

**8 · Phase 3: hand a note to an AI agent**

```
I want the AI agent to see my notes, like in handwriting, and like read my handwriting, and also look at the transcript and see what note I was taking there at a certain time, and then just take all of that, and then understand what, you know, repo to go into. Basically, what tasks to do? And then just like run with that task based on the note. And I literally, it's probably just like one button, like hand over to an agent.

Maybe the transcripts could just be stored in the cloud, and then when I hit copy, the agent will have immediate access to that. So I don't need to export the transcript and feed it into the agent, and then it can give the PDF of the actual of my handwritten notes as well.

We're probably going to need speaker detection as well, and an ability to change the speaker names as well and store people's speaker names.
```

_The Phase 3 prompt as it appears on screen in Pat's video at 25:20._

Phase 4 added sign-in and a Postgres database, both from Neon, so each person's notes follow them to another iPad.

**9 · Phase 4: accounts and a real database**

```
Add sign-in and a real database to this app so more than one person can use it, each with their own notes.

Use Neon for both. Neon now does authentication as well as Postgres, so set up Neon Auth rather than bolting on a separate auth service. Create the schema, wire the connection string in properly instead of hardcoding it, and make sure the users Neon Auth creates are readable from my own tables.

Then go through everything the app currently stores on the device (notes, recordings, transcripts, subjects) and give each row an owner, so signing in on a different iPad brings my own notes down and nobody can read anyone else's. Tell me what happens to the notes already on my device when I sign in for the first time, and handle that migration rather than losing them.

Keep the app working offline. It should not need a connection to open a note I already have.
```

**10 · Phase 5: make it production ready**

```
Set up more database storage, and authentication, and anything else if needed, to get this to a fully functional, production ready application.
```

The code is public at github.com/per-simmons/inkwell. Pat's rebuild post explains that a free Apple ID can install it on your own iPad, but the app stops opening after seven days until you build it again, and $99 a year to Apple stretches that to a year.

## Big build prompts: what Opus 5.5 made, and the cost

Pat's two big build prompts below cost $37.22 and $11.66 to run on Opus 5.5, at API list prices worked out from each session's logs. He gave Opus 5.5, Claude Fable 5.1 and GPT-6 Astra the same prompts, and in his results post he wrote, "Opus 5.5 won all three, and it wasn't especially close."

Both prompts are long, and each one spells out a reference to study, the exact format, the requirements as a numbered list and what to hand back, which is the kind of detail Claude can't guess.

**11 · Moby Dick, scene by scene**

```
Make "Moby Dick, scene by scene": a single HTML file in which every scene, person, wave and ink dot is drawn in code, in the exact format of the reference below.

Context you should know: this is going into a video watched by a large audience. Your build is put on screen next to two other frontier models doing the same task and next to the original, and your work will be credited to you by name. Every model gets this identical prompt.

**The reference.** Open https://a-small-light-three.vercel.app/ and study it for a while: the overview, the tour, a close-up of a room. Kevin Ngo made it with Claude Opus 5: "I made a website with 25 mini rooms, each with Claude keeping people company. It's all JavaScript in one HTML file. There are no images, fonts or libraries. Every room, person, and ink dot is drawn in code." Your build uses the same format and the same print technique, with Moby Dick as the subject. Write your own code; do not copy his.

**The format, exactly:**

1. **One HTML file, nothing else.** A few lines of CSS, one full-screen ``, one small overlay for the chapter card, and one script. No images, no data-URI images, no font files, no libraries, no external scripts, no network requests. Canvas 2D only, no WebGL. The only text anywhere is the chapter card (requirement 10), set in system font stacks. The page must load with exactly one network request, itself.
2. **A simulated risograph print.** Every colour is a halftone dot screen of one of **four spot inks** on warm cream paper, overprinted with multiply so the secondary colours come only from overlaps. Each ink has its own screen angle and its own slight misregistration offset. Dots get small jitter, solids get random ink dropout, and objects knock out what is behind them the way a printer's knock-out does. Choose four inks that suit a whaling voyage.
3. **Hand-drawn linework that boils.** Every line wobbles, and lines taper. Bake each scene in three variants with different wobble seeds and cycle them at about 3 Hz, so the linework breathes like hand animation on twos. All randomness is seeded, so the same scene draws the same way on every load.
4. **Light is ink.** Lamp pools, the try-works fire, the corposants and moonlight are stepped halftone rings, never smooth gradients.
5. **Isometric dollhouse dioramas.** Each scene is a cut-away isometric slab, like a dollhouse with the near walls removed: a room ashore, a slice of the Pequod's deck and rigging, a patch of open sea with whaleboats. All scenes sit together on **one printed sheet**, packed into a single block like a poster, with registration crop marks, edge crosshair targets and an ink swatch strip in the margins.
6. **The white whale in every scene**, the way the Claude spark is in every one of Kevin's rooms: a small presence, sometimes obvious and sometimes hidden. A carving on the chapel pulpit, a shape in the ocean, the doubloon's engraving, a spout on the horizon, the thing on the chart Ahab traces.
7. **Realistic people, not stick figures.** Every figure is a properly proportioned, illustrated human body: head, neck, shoulders, torso, hips and limbs drawn as solid, tapering volumes with real anatomy, then dressed in period clothing with weight and folds (pea coats, oilskins, wool trousers, boots, hats, Ahab's whalebone leg). Faces carry features when you zoom in: brows, noses, beards, Queequeg's tattoos. Draw the bodies, clothing and shading in the same risograph inks as everything else, so the people look printed in the same hand as the ship. Line figures, stick limbs, or circle heads on single-line bodies are a fail. Figures share one skeleton with keyframed pose clips (walk, haul, row, sit, point, climb, sleep, harpoon, pray, and so on), the body volumes deform with the joints, and they follow paths through their scene on a loop. Ishmael, Queequeg, Ahab, Starbuck, Stubb and the crew should be recognisable at a glance.
8. **It prints in, then tours.** The sheet appears first, with scenes painting in progressively as if coming off the press. After a few seconds the camera eases into the first scene, holds, and moves through the book in order. Any input pauses the tour and then it resumes. Drag to pan with inertia, scroll to zoom anchored on the cursor, pinch on touch, double-click a scene to fly to it, arrow keys and +/- work, and 0 fits the sheet. Apart from the chapter card there is no UI and there are no labels.
9. **The scenes.** Twelve or more, in book order, each a distinct and picturable moment, with enough going on to reward a close zoom. For example: Loomings on the Manhattan wharves (ch. 1), the Spouter-Inn (ch. 3), the Whaleman's Chapel pulpit (ch. 8), Queequeg and Ishmael by the fire (ch. 10), the Pequod fitting out (ch. 16), the Quarter-Deck and the doubloon (ch. 36), the mast-head (ch. 35), the Grand Armada (ch. 87), the try-works at night (ch. 96), the Candles (ch. 119), the three-day Chase (ch. 133–135) and the Epilogue's coffin life-buoy. Pick your own set and put the list, with chapters, in a comment at the top of the file.
10. **The chapter card.** Whenever the camera settles on a scene (on the tour, or when the viewer flies to one), a card eases in over a corner of the screen and eases out when the camera moves on. It is styled like the opening page of a chapter in a fine printed edition: the chapter number in roman numerals and small caps ("CHAPTER XXXVI"), the chapter title in a large book serif ("The Quarter-Deck"), a thin rule or printer's ornament, then a pull quote from that chapter in italic with a drop cap and proper curly quotes. Cream stock with the same paper grain and one of the four inks as the accent colour, so it looks printed on the same press as the sheet. Every quote is copied verbatim from the Project Gutenberg text (https://www.gutenberg.org/ebooks/2701). Use system serif stacks only (for example `"Iowan Old Style", "Palatino", "Book Antiqua", Georgia, serif`); no font files. A key (C) toggles the card.
11. **Performance.** A smooth frame rate at full screen on a laptop (cache layers, redraw only what moves), crisp on a 4K display, and working on a phone.
12. **Ship it.** The single `index.html`, plus a README with its byte size, the scene list with chapters and the quote used for each, the four inks, and how the print simulation works.
```

_What Opus 5.5 made from the Moby Dick prompt, in 85 minutes for $37.22 at API prices. Open the live build; costs from Pat's results post._

**12 · A launch film and launch page**

```
Invent a launch, make its 20-second launch film, and build its launch page with a torn-paper reveal and the film embedded.

Context you should know: this is going into a video watched by a large audience. Your build is put on screen next to two other frontier models doing the same task, and your work will be credited to you by name. Every model gets this identical prompt.

**Study the references first.** Watch both films frame by frame (ffmpeg is installed) and scroll the Opus 5.5 launch page in a headless browser. The film: about 40 hard cuts in 20 seconds, getting faster as it goes. Every shot is a macro or microscope-like image of a different material, such as pollen, egg shell, lace, mushroom gills, a blueprint, torn paper or fruit skin. Every shot is composed around the same curved horizon, so one arc rhymes into the next. There's heavy film grain. Three short serif phrases grow in size, the film ends on the name, and the last frame loops back into the first. The page: three torn-paper panels fade up from black, and "Introducing" rises out from behind the planet's edge. On scroll, the torn scraps slide outward while staying locked to the curve, and the title rises and wipes on with a letterpress ink texture. The torn edges have a fibrous white paper seam on one side and a cast shadow on the other.

**The launch is yours.** Pick a subject: a product, a model, a mission, an expedition, a scientific instrument, anything with a reason to be revealed. Invent its name. It must not be an Anthropic product, and there must be no Anthropic or Claude branding anywhere. Say what it is in one sentence on the page.

Requirements:

1. **The film. 20 seconds, 1920×1080, H.264 MP4 with an audio track, rendered by you.**
   - Every image in it comes from the shared image tool (gpt-image-2, the same one for every model). **At most 40 images.** No stock, no downloaded images, no images lifted from the references.
   - Design the shot list around one repeating composition, the way the reference does, with a different material each time and chosen to suit your subject. Grade, grain, crop and align the shots in your own code so the arcs actually line up cut to cut.
   - Cut rhythm that accelerates, on-screen text in a few escalating phrases, the name at the end, and a last frame that loops cleanly into the first.
   - Assemble and render it yourself (ffmpeg, or frames from your own renderer). Check the result frame by frame.
2. **The sound. All of it synthesised in code. No sample files, no downloaded audio, no sound libraries.** Web Audio, or offline DSP in any language, rendered to the film's audio track.
   - **Realistic paper foley** is the centrepiece: not one generic crumple, but a family of distinct sounds, such as a sheet sliding across paper, a stack being shuffled, a page turning, a slow tear with fibres giving way, a crumple, a flick, a scrap landing. Each one has to sound like the real thing, so build it from noise, filters, envelopes, granular texture and randomisation. Two plays of the same sound should never be identical.
   - Hit every visual beat the way the Kimi K3 film does: each cut, each text change and the final reveal has its own sound. Add a music bed or tonal bed of your own if it helps. Keep it clean and mixed, with no clipping.
3. **The launch page.**
   - **The hero reveal**, with the Opus 5.5 page's mechanics as the target: three torn-paper collage panels made from your own generated imagery. They fade up from black, an intro word rises from behind a curved horizon, and on scroll the side scraps slide outward while staying locked to the curve, then your launch name rises and wipes on with a speckled letterpress ink texture.
   - **The torn edges are drawn in code:** a noise-driven, fibrous tear, a thin exposed paper seam on one edge, a soft cast shadow on the other, and film grain over everything. Not a PNG mask.
   - **The same paper foley plays live on the page**, synthesised in the browser: the scraps sliding, the title landing, pages turning as sections enter. Start sound on first click or keypress (browsers block autoplay audio) and show a small sound toggle.
   - **The film is embedded** in the page as its centrepiece, with the page's own player styling.
   - Below that, a short launch article for your subject in the same typographic voice: a date eyebrow, a table of contents, and three or four sections. Use a serif and a sans from an open CDN. Anthropic's fonts are off limits.
4. **No lifted assets.** Nothing downloaded from anthropic.com, x.com or Kimi. No copying the reference page's code or shaders. Rebuild the effects from what you observe.
5. **Ship it runnable.** A static site that runs from one documented command, deployable as-is, with the MP4 inside it, and a README listing the subject, the shot list with each image prompt, how each sound is synthesised, and the image count.
```

Opus 5.5 finished its launch film build in 40 minutes for $11.66. Pat noted that its film came closest to Anthropic's own, and that sound design was the weak spot for all three models.

## Which prompt tricks don't work on Claude?

Personas, "think step by step," "check your work three times," all caps, "don't be lazy" and bribes didn't work on Claude Opus 5.5 in our test. The trimmed and bare prompts left them out and still got every main answer right, so these lines made the prompt longer without changing the result.

- Personas: "world-class executive assistant" and "senior data analyst with a PhD" changed nothing.

- Thinking instructions: "take a deep breath and think step by step" mostly made spreadsheet answers longer and slower.

- Triple-checking: the shorter prompts caught every trap without it.

- Shouting: Claude followed plain-sentence versions of the same rules just as well as CRITICAL and all caps.

- Pressure: "This is extremely important to my career" and "I'll tip you $200" did nothing we could see.

Old rules can also backfire. The long meeting prompt said to write "No deadline" when none was stated, so all three long runs labeled the newsletter task "No deadline (the newsletter goes out Nov 1)," while the trimmed and bare prompts wrote "Before Nov 1."

Longer prompts still make sense when the length is the material: a style guide, examples you want matched, or a build spec like Pat's two above.

## Is there a free Claude AI course or certification?

Yes. Anthropic's course site, Anthropic Academy, has these courses, and each course page showed Register | FREE when we checked on November 2, 2026. Two of them offer a certificate of completion:

- Claude 101: using Claude for everyday work tasks, ending with a certificate of completion.

- AI Fluency: Framework & Foundations: a final assessment, then a certificate of completion.

- Claude Code 101: using Claude Code in your daily development work.

- Claude Code in Action: running long, hands-off Claude Code sessions and checking what came back.

- Introduction to agent skills: building and sharing skills in Claude Code.

Anthropic's formal certification is a paid exam. The Claude Certified Architect Foundations exam was listed at $125, and it tests Claude Code, the Claude Agent SDK, the Claude API and the Model Context Protocol, so it's aimed at people building software on Claude.

## Questions people ask about Claude prompts

Is Claude Code free?
No. Claude's plan comparison marks Claude Code "No" on the Free plan and includes it on Pro ($20 a month billed monthly), Max and Ultra.

How many Claude prompts can you send per day?
Most Claude plans have a limit that resets every five hours plus a weekly limit, and Ultra drops the five-hour one for verified accounts. Our post on Claude's Ultra plan covers what each plan gets.

What's the difference between a prompt and a Claude skill?
A prompt is what you type each time, and a skill is a saved job Claude can reuse. A skill is "a folder" holding "a SKILL.md file of instructions, plus any scripts and reference docs the job needs," and Claude reads it when your request matches. You can install Pat's for free from Claude skills: what they are and four Pat built.

Which Claude model did these prompts run on?
All 12 ran on Claude Opus 5.5, which Anthropic released in September. Models and features change often, and our page on what's new in Claude tracks each update.

Can I reuse these prompts for my own app?
Yes. The app prompts all follow one shape: who you are, the annoying problem, what you want to see and how you'll use it. Swap in your own details and react to what comes back in plain English, the way the second Who Owes Me prompt does.

## How we tested these prompts

Every prompt on this page ran on Claude Opus 5.5, and each result comes from the post linked in its section.

- Everyday prompts: three jobs, each in a long, trimmed and bare version, three runs per version, 27 runs in all. They ran at Opus 5.5's default effort setting through Claude Code with its tools switched off, and every answer was checked against an answer key.

- Who Owes Me: Claude Code in an empty folder, with the three prompts sent in order and the screenshots taken from the app it built.

- Notability rebuild: Pat's six phase prompts in Claude Code, in order, each reacting to the last result, with the app installed on his iPad.

- Big builds: Opus 5.5 ran in Claude Code on high effort, got each prompt once and worked until the build was finished. Costs are what the model worked out from its own session logs at API list prices; the builds themselves ran on subscriptions.

## Sources

- Are Your Long Claude Prompts Worth It? We Cut Them Down to Find Out, AI for Mortals

- Claude Code for Beginners: We Built a Small App Without Writing Any Code, AI for Mortals

- I rebuilt a $5M/month app with Claude Opus 5.5, AI for Mortals

- I Made Opus 5.5, Fable 5.1 and GPT-6 Astra Build the Same App, AI for Mortals

- Inkwell source code, GitHub

- Prompting Claude Opus 5.5, Claude Platform Docs

- Claude plans and pricing, Anthropic

- Anthropic Academy courses, Anthropic

- Claude Certified Architect Foundations Certification, Anthropic Academy