Claude Code in one evening. A guide.

You already know your way around ChatGPT, Copilot, or web Claude. That's a good base. But everything you did there was working in a sandbox: you asked, copied the answer, pasted it by hand. Claude Code is different. It's the same model, but with hands. It works right inside your files, on your own computer.

This guide moves you, in one evening, from "chat in a browser" mode to "AI as a working tool" mode. No code. No jargon.

1. Why leave the chat window at all

Chat is 2024. You copy context into the window by hand, the model never sees your files, and by the next day everything's forgotten.

The real value shows up when the program sits on your computer and has access to your documents. It reads a folder, edits files, runs a prototype, searches the web, and puts the result back on disk. It's not engineers who build working things in an evening when they have domain expertise and the right tool in hand.

One idea matters most: whoever is best at assembling context wins. Claude Code is a tool for assembling context.

2. What this is, in your terms

Simpler version: picture an intern sitting at your computer, who can see your files and does whatever you tell them, in words. That's Claude Code.

3. Three mental switches

This is the hardest part. Not the install, but the habit change. Until you make these three switches, the tool will just feel like an awkward chat window.

1. From copy-paste to files. Stop copying answers out. Say instead: "rewrite this document," "create a file with this content," "fix this part." The model works with disk, not with your clipboard.

2. Context hygiene. The more you cram into one conversation, the faster the model gets dumber. The context window clogs up. Rule of thumb: a new session per task. Keep anything permanent in files, not in chat history.

3. Check every single word. The model never hands you a fully correct result. It's mostly right, but wrong in places. A domain expert with AI replaces someone without domain expertise. The expert themselves is not replaced. You stay the editor, not the audience.

4. Setup in 15 minutes

1. Set up an account and a subscription. Real progress starts once you've decided: yes, I'm ready to pay. The minimum to get going is around $20/month, enough to get a feel for it. The premium tier, around $100/month, is for when you're in the tool every day and keep hitting limits. Free-tier limits run out fast and get annoying.
2. Install Claude Code on your computer (desktop app or CLI, whichever feels more comfortable). The web version is fine for warming up; real work happens on desktop.
3. Create a project folder on your desktop. One folder, one project.
4. Open Claude Code in that folder. That's it - the model now has eyes and hands.

A note on economics: Russian, Polish, and Ukrainian text eats up 1.5-2x more tokens than English. Keep that in mind when estimating usage.

5. Your first session

Don't overthink it. Three steps:

1. Put all the context into the folder: a brief, notes, data, whatever you have on the project.
2. Open Claude Code in that folder.
3. Say, in plain words, what you need. For example: "read these files and put together a one-page brief from them" or "build a quick and dirty prototype from this spec."

Voice input is 2-3x faster than typing. Dictate, then proofread. That's not laziness, that's speed.

6. Five moves that are enough for a beginner

You don't need to know a hundred commands. You need five.

1. "Read the folder and tell me what you found." This is how you check that the model actually sees your context.
2. "Create a file / fix this file." Basic work with disk.
3. "Search the web and put together a table." Research, right inside your workflow.
4. "Explain what you did and why." Make the model show its reasoning. It's easier to catch mistakes that way.
5. New session. Finished a task - open a fresh session for the next one. Don't drag the clutter along.

7. How to write better prompts

A prompt is what you type in. The quality of the answer equals the quality of the prompt. Garbage in, garbage out. This is the skill that improves fastest and pays off the most.

Five rules to make your prompts stronger:

1. Role + task + constraints + format. Not "sort out these expenses," but "you're an experienced financial analyst, sort these expenses into categories, don't invent new ones, use mine, give me a table." The tighter the frame, the less the model makes things up.
2. Give an example. Show 1-2 examples of what you want. The model copies a sample better than it interprets a description.
3. Say what NOT to do. Bans work. "Don't use em dashes," "don't pad it with filler," "don't make up facts."
4. Plan first, then act. "Show me a plan before you start." You catch a mistake before the model has burned an hour going the wrong direction.
5. Iterate. The first answer is a draft. "Too long, cut it in half," "add numbers," "rewrite it tighter." A good result takes 3-4 rounds of edits, not one perfect prompt.

The main trick: let Claude write prompts for you. This changes everything.

• "Write a prompt that would make you do this task well."
• "Improve my prompt: [your text]." The model will sharpen it and fill in what you missed.
• Save a prompt that worked well into a file and reuse it. That's how a one-off success turns into a repeatable process.

Early on, the model is better than you at knowing how to talk to itself. Use that.

That's the basics. Beyond this there's more advanced stuff: skills (ready-made capabilities the model plugs in on its own when needed), MCP and external connections over URL (email, calendar, databases, your own services). That's what turns Claude Code from an assistant into a working system. We go deep on this in the course and in the practical group.

8. Context is everything

Think of it as a folder of documents. You build it by hand: project description, your role, the subject matter, market data, your target audience, the spec, marketing materials. The better the folder, the smarter the model.

One file is worth setting up right away: a short project description the model reads every time. Who you are, what you're building, what the rules are (for example: "don't use em dashes, write in English, check facts"). Those are your guardrails. Write it once, and the model keeps following it.

More advanced tools can offload subtasks to separate sub-agents without cluttering the main context. That's the next level, but it's worth knowing about already.

9. Beginner pitfalls

• API keys and limits. The first time, you'll hit a request for a key or a daily limit. That's normal, don't panic. The result is never perfect on the first try.
• Context clutter. If the model starts getting dumb and forgetful - don't fight it, just open a new session.
• Blind trust. The most expensive mistake. Generate, then check. Especially numbers, facts, links.
• Vibe coding has a ceiling. A quick prototype is weak on quality, security, and scale. The moment it starts making money - rebuild it properly, with people who know what they're doing.
• Ten ideas at once. Pick one. Not three.

10. Where to start: simple projects

Don't invent a startup. Take a boring task from your own life and automate it. Here are projects a beginner can actually finish in an evening or two. Pick one.

• Career agent. Put your resume, job listings, and notes into a folder. Ask it to: tailor your resume to a job listing, find gaps in your experience, build a list of companies, draft a cover letter. Context about you piles up in the folder and works for every application.
• Finance agent. Export a bank statement (CSV or Excel), and say: sort expenses into categories, find subscriptions, figure out where the money's leaking, put together a monthly report. No apps, just a file and a couple of prompts.
• Telegram bot. The most "wow" first project. A bot that answers common questions, collects requests, or sends reminders. Claude Code builds the skeleton, you connect it following instructions. This isn't a toy anymore, it's a working thing.
• Connecting to your inbox. Give an agent access to your mailbox: have it sort incoming mail by topic, draft replies, pull tasks out of emails, put together a daily summary. An hour of routine work a day adds up to weeks over a year.
• Personal knowledge base. A folder of notes, articles, write-ups. Ask it questions like a live expert: "what did I write down about X," "pull everything about Y into one summary."
• Research assistant. Give it a topic, ask it to: search the web, compare options, put together a table with pros, cons, and links. A ready-made deep research run for your task.

Rule for picking: take whatever is bugging you personally right now. Your own pain point means you're your own first user, and feedback is instant.

11. A quick win: from idea to prototype in one evening

Work like a scientist. Investigate the problem first, then build. Three phases:

1. Discovery. Segment your audience, sketch 3-5 personas, run a synthetic interview, do deep research on competitors. The outcome of this phase might be: nothing needs building, a solution already exists. That's a result too.
2. Solutioning. If the hypothesis holds up and nobody's solving the problem yet - write a light spec. One page, not fifty. What problem you're solving, for whom, what makes you different.
3. Development. Load the spec into Claude Code and say: build it quick and dirty. Show it to 5-10 real people. Improve it or shelve it.

Think about go-to-market, pricing, and support only after value is confirmed. Not before.

This week's checklist

• ☐ Set up a subscription, installed Claude Code on your computer.
• ☐ Picked one project. One.
• ☐ Created a folder, put all the context into it.
• ☐ Set up a file with the project description and rules.
• ☐ Opened Claude Code in the folder, gave it a first task in plain words.
• ☐ Ran Discovery: personas, synthetic interview, competitor research.
• ☐ If the hypothesis held up - built a prototype and showed it to 5-10 people.

Whoever has more context wins. Start building yours.