5 projects to get started with AI, with the exact prompts to paste into Claude Code

A clean, editable personal site, with no paid template and no page that looks like everyone else's. It's the fastest of the five, and the one that pays off soonest.

30 to 45 minutes · about $0 (Vercel free tier, negligible tokens) · Node 20+, a Vercel account.

Start by installing Anthropic's official design skills library, which gives Claude Code component conventions instead of letting it improvise:

/plugin marketplace add anthropics/skills

Then the three prompts, in order.

Create a Vite + React + TypeScript project called `portfolio`. Install and
configure Tailwind CSS and shadcn/ui: run `npx shadcn@latest init` with the
"new-york" style and the "stone" base color. Configure the `@/` alias in
tsconfig.json AND vite.config.ts (otherwise the shadcn imports break).
Structure: `src/components/` for the sections, `src/App.tsx` to assemble them.
Create 5 empty but typed components: Hero, About, Projects, Contact, Footer.
Run `npm run dev` and confirm the page renders on localhost:5173.

Here's my info: [YOUR NAME], [YOUR ROLE in one line], 3 projects with {title,
short description, link}, email [YOUR EMAIL]. Fill in the 5 sections. Hero: large
title (Fraunces or a serif via @fontsource), subtitle, 2 shadcn `Button`s.
Projects: one shadcn `Card` per project. Contact: a styled mailto link. Palette:
stone-50 background, ONE consistent accent color that you choose. Responsive,
mobile-first. No animation library for now.

Add smooth transitions: global `scroll-behavior: smooth` and a `transition` on
Card hover (no library). Check WCAG AA contrast on all text. Then `npm run build`,
fix any TypeScript errors, and deploy with `vercel --prod`. Give me the final URL.

You should end up with src/App.tsx, src/components/{Hero,About,Projects,Contact,Footer}.tsx, tailwind.config.js, components.json and tsconfig.json.

A task app with the same design system in the browser and on your phone. The point isn't the to-do list, it's learning to share logic across two platforms without rewriting it.

1 to 2 hours · about $0 · Node 20+, the Expo Go app installed on your phone.

Create a to-do app in React + TypeScript (Vite). Features: add a task, check it
off, delete it, filter (all / active / done). Persist to localStorage. Put all the
logic in a reusable `useTodos()` hook (that's the one we'll share with mobile).
Minimal design: centered list, input at the top, checkbox on the left. Run it and
confirm it works on localhost.

Now create an Expo app (React Native, TypeScript) called `todo-mobile` that
reuses EXACTLY the same logic as the `useTodos()` hook. Copy it and replace
localStorage with AsyncStorage (`@react-native-async-storage/async-storage`).
Replicate the design: same hierarchy, same colors. Use `expo start` and give me
the QR code to scan with Expo Go.

Create a shared `theme.ts` file (colors, spacing, font sizes) and make both web
AND mobile import it, so the design system stays identical. Add an empty state
("No tasks, add one") and a remaining-task counter at the bottom. Verify that
checking a task persists after a restart on both platforms.

You should end up with web/src/hooks/useTodos.ts, web/src/App.tsx, todo-mobile/App.tsx and todo-mobile/theme.ts.

An animated video intro written in React and rendered to MP4, without ever opening an editing tool. It outputs vertical, ready for Reels and TikTok.

45 minutes · about $0 (local render) · Node 20+ only.

First install the skill maintained by the Remotion team, which holds the model to the library's conventions:

/plugin marketplace add remotion-dev/skills

Create a Remotion project (`npm create video@latest`, "Hello World" template,
TypeScript). Explain the structure to me: where the Composition lives, where I set
fps (use 30) and duration (use 4 seconds, so 120 frames), format 1080x1920
vertical.

Create a 4-second intro at 1080x1920: (1) my text [YOUR TEXT] appearing with a
`spring()` scale from 0 to 1 over the first 20 frames, (2) a subtitle fading in
underneath between frames 30 and 45 using `interpolate()` on opacity, (3) a subtle
continuous background zoom across the whole duration. Background color [YOUR
COLOR]. Follow Remotion best practices: no animation based on Date.now(),
everything goes through useCurrentFrame.

Render the video to MP4:
`npx remotion render src/index.ts MyComposition out/intro.mp4`. If the render
fails, diagnose it. Give me the final file path and its size.

You should end up with src/Composition.tsx, src/Root.tsx, src/index.ts and out/intro.mp4.

One detail a lot of tutorials still get wrong: you don't need to install ffmpeg. Since Remotion 4, a lightweight build of ffmpeg ships with the library, and rendering works with no system install at all. If you hit an instruction telling you to install it by hand, it predates that.

Your inbox sorted and labeled on its own, every fifteen minutes. It's the first of the five that saves you time every day instead of simply existing.

1 hour · a few dollars a month at most · a Make account, a Gmail account, an Anthropic API key.

Make's free plan covers 1,000 credits per month, which is plenty for personal email volume. On the model side, Claude Haiku 4.5 (claude-haiku-4-5) is the cheapest in the lineup and more than enough to stick a label on an email.

This one happens in two stages. First the classification logic, tested inside Claude before you wire anything up:

Write me an email classification prompt that takes {sender, subject, body excerpt}
and returns ONLY one label from this closed list: [Client, Invoice, Newsletter,
Personal, To handle]. No text around it, just the label. Add one rule: if
uncertain, return "To handle". Test it on 5 examples I give you.

Then the automation scenario:

Walk me through building this Make scenario step by step: (1) a Gmail "Watch
emails" trigger on new mail, every 15 minutes, (2) an HTTP or Anthropic module
sending {from, subject, body truncated to 500 characters} to Claude Haiku with my
classification prompt, (3) a router that applies the Gmail label matching the
response. Give me the exact config for each module: method, endpoint, headers,
field mapping.

You walk away with the JSON export of the Make scenario and your prompt_classification.txt.

A terminal assistant that answers your questions and knows how to use tools on your behalf. This is the project that moves you from "I chat with a model" to "I build a system that acts."

1 hour · a few cents in usage · Python 3.10 minimum, an Anthropic API key in the ANTHROPIC_API_KEY environment variable.

Create a Python project with the Claude Agent SDK (`pip install
claude-agent-sdk`). Write `agent.py`: an agent with the system prompt "You are a
concise, factual personal assistant", a terminal loop that reads my question,
sends it to Claude, and prints the answer. Handle `Ctrl+C` cleanly. Confirm I can
ask a question and get an answer.

Add a first tool to the agent: `get_current_weather(city)` that calls the
open-meteo API (free, no key). Declare the tool to the SDK with a typed input
schema. When I ask for a city's weather, the agent should call the tool and work
the result into its answer. Show me the logs of the tool call.

Add a 2nd tool `save_note(text)` that writes to a local `notes.txt` file, and keep
the conversation history in memory (a list of messages) so the agent has the
context of previous exchanges. Test it: ask for the weather, then say "note it",
and check that the note contains both the city and the temperature.

You should end up with agent.py, notes.txt and requirements.txt.

Two verified details that save you a debugging session: the PyPI package requires Python 3.10 or higher (not 3.11, despite what you'll often read), and the open-meteo API does answer without any key, so there's nothing to set up on the weather side.