From building live apps in minutes to deep research mindmaps and bulk file automation — a software developer's honest walkthrough of Claude from basics to Cowork.
Let me be honest about where I started: I was using Claude occasionally — mostly for quick code reviews and drafting emails — but I had no real system. A colleague pointed me to a structured Claude AI course, and I decided to commit to going through it properly, section by section, with my actual work in front of me.
What I didn't expect was how quickly "a productivity tool I used sometimes" would become the backbone of how I approach everything — from deploying live web apps to managing bulk files with OCR. This article is that journey, phase by phase.
Here's the thing about "basics" — they set the mental model for everything that follows. The course doesn't just show you how to chat with Claude; it walks you through how Claude thinks. The context window, how conversations are structured, what makes a good prompt versus a lazy one.
For me, the lightbulb moment was understanding that Claude isn't a search engine. You don't query it — you collaborate with it. When I stopped asking "what is X" and started saying "here's my context, here's my constraint, here's what I want to achieve" — the quality of responses jumped dramatically.
Claude performs best when you give it your full situation, not just a question.
Each conversation is a fresh context window — understanding this shapes how you structure sessions.
Specificity isn't just helpful — it's the difference between a generic answer and a genuinely useful one.
"Claude isn't a search engine you query. It's a collaborator you brief."
I need to tell you about the first time I saw Claude build a fully working web app inside the chat window. I'd asked it to create a simple project status tracker — something I'd normally spend half a Sprint building — and within about 90 seconds I had a responsive HTML dashboard with filter controls, status badges, and a clean layout. I hadn't written a single line of code.
Artifacts are Claude's output format for runnable, editable content. They live in a side panel, can be iterated on in real time, and — critically — can be exported. The course covers the full lifecycle: generating an Artifact, refining it through follow-up prompts, and getting it ready for actual deployment.
The course uses a health survey app as its hands-on project — and it's a brilliant choice because it requires real logic: multi-step forms, conditional questions, input validation, result calculation, and a summary screen. These aren't trivial requirements. This is the kind of app that usually takes a junior dev a few days to wire up properly.
Claude built the full working app — including a responsive layout, score calculation based on responses, and a results card with colour-coded health indicators — and then the course walked through deploying it live. By the end of that section, I had a public URL I could share. Total time from "blank screen" to "live app": under 40 minutes, including learning pauses.
"The gap between 'I wish we had a tool for this' and 'here's a working prototype' is now measured in minutes, not sprints."
This one surprised me. I'd accumulated a lot of context in ChatGPT over the past year — project notes, preferences, prompts that worked well. The idea of starting from scratch in Claude felt like a real friction point. This section of the course addresses that directly.
Claude supports importing conversation history and memory exports from other AI tools. The process involves exporting your data from ChatGPT or Gemini, then structuring key context into a format Claude can ingest — either as a memory note or as part of a Project's system context. It's not a one-click sync, but it's far less painful than it sounds.
Use the data export feature in ChatGPT settings to get your conversation history as a structured JSON file.
Don't import raw history — extract the key facts, preferences, and rules that made those conversations work.
Paste distilled context into a Project's system prompt to make it persistent across all conversations in that Project.
The Connectors section was where Phase 1 really clicked for me as a developer. Up until this point, Claude was producing great outputs — but I still had to manually copy files, push to Git, configure deployments. Connectors change that entirely.
The course demonstrates deploying an Artifact directly to Netlify via Claude's Connector integration. You build the app in Claude, then tell Claude to deploy it. Claude handles the Netlify API interaction. You get a live URL without touching a terminal.
"The best deployment workflow is the one where I don't have to think about deployment at all."
I appreciate that the course dedicates a full section to pricing — it's one of those things that's genuinely confusing until someone maps it out clearly. As a developer thinking about team adoption, understanding the plan tiers is as important as understanding the features.
The key decision point for most developers is whether the Pro plan's higher usage limits and priority access justify the cost versus the free tier. For anyone using Claude daily — and especially for teams using Projects and Cowork features — the answer is almost always yes. The course also covers the Team and Enterprise tiers, which are relevant if you're evaluating Claude for wider internal adoption at your company.
Phase 2 begins with Cowork — and I want to be clear about what this is, because the name undersells it. Cowork isn't a chat feature or an add-on. It's Claude's agentic layer: the ability to operate on your local file system, run multi-step workflows, interact with your actual documents and folders, and execute tasks that persist beyond a single conversation.
Setting up Cowork involves installing the Claude desktop app and configuring it to have the access it needs. The course walks through this carefully — which permissions to grant, how to verify the connection, and how to sanity-check that Cowork is running correctly before you start giving it real tasks.
CLAUDE.md file (covered in a later section)This section reframes everything. The course presents a mental model for Claude maturity — five levels of how deeply you're integrating Claude into your workflow. It starts from basic chat (Level 1) and builds all the way to Cowork-powered autonomous task execution (Level 5).
One-off conversations. Good for quick lookups, code reviews, email drafts.
Persistent context across conversations. Your tech stack, team norms, and project state are always loaded.
Reusable instruction sets that make Claude an expert in specific workflows — content creation, code review, data analysis.
Agentic file system access. Claude operates on your actual documents, folders, and data — not just in the chat window.
"Most developers are living at Level 2. The jump to Level 3 alone would save them hours every week."
The course uses the TCS annual report as a live demo — and it's a genuinely impressive demonstration of what Projects + Cowork can do together. You hand Claude a dense, multi-hundred-page PDF, and the workflow produces a clean, interactive dashboard with KPIs, charts, and segment breakdowns.
What makes this powerful for me as a developer isn't the financial data — it's the pattern. The same workflow applies to any structured PDF: a client requirements document, a product specification, an API reference. Claude reads the document, extracts the structure, and builds a visual interface on top of it.
This was one of my favourite discoveries in the entire course. CLAUDE.md is a plain text file you place in a folder that Cowork has access to. It acts as a standing instruction set for Claude whenever it works in that directory — persistent rules that don't need to be repeated in every conversation.
The course shows three primary use cases for CLAUDE.md: folder-level instructions ("always name output files with a date prefix"), a lightweight backup protocol ("before modifying any file, copy the original to /backup"), and an activity log ("append a one-line entry to log.txt after every task"). Together, they transform ad-hoc file operations into something that feels genuinely governed.
"CLAUDE.md is the difference between 'Claude did something to my files' and 'Claude followed my rules while working on my files.'"
I'll admit I was sceptical about this one. Mindmapping has always felt like a thing I should do more but never actually do. The course demo changed my view entirely — not because of the mindmap itself, but because of what Cowork does before generating it.
The workflow: give Claude a research topic, let it run a multi-step deep research cycle (searching, synthesising, cross-referencing), then export the structured output as a MindNode-compatible file. The result is a properly organised mindmap with branches, sub-branches, and source annotations — not a flat list dressed up as a tree.
This section genuinely impressed me, because it solved a problem I'd quietly given up on: my "Downloads" folder and the various "working" folders on my machine that accumulate scanned PDFs, screenshots, and renamed files with no consistent naming convention.
Cowork can read files — including images and scanned PDFs via OCR — and then rename, reorganise, and sort them based on their actual content. Not by filename. By what's inside them. The course demonstrates this on a bulk folder of mixed documents and shows Claude correctly categorising and renaming them in a single workflow run.
CLAUDE.md in the target folder before running bulk operations. Defining your naming convention in advance means Claude applies it consistently — rather than making judgment calls you might not agree with after the fact.The final section covers what might be the most immediately practical Cowork workflow for anyone in a team environment: working with CSV data. The course covers two distinct use cases — editing and cleaning a CSV (for sharing with a colleague or accountant), and generating a full visual dashboard from a CSV file.
The cleaning workflow is particularly useful for anyone who regularly exports data from Jira, GitHub, or internal tools. These exports are rarely clean — inconsistent column names, mixed date formats, blank rows, duplicate entries. Cowork can audit the file, report what it finds, and then clean it according to rules you define.
Remove blanks, fix date formats, standardise column names, deduplicate rows — all in one pass.
Claude reads the CSV and generates a full HTML dashboard with charts, KPIs, and trend lines — ready to open in any browser.
Produce a clean, well-formatted CSV alongside a summary sheet — shareable without further manual work.
"I used to spend Friday afternoons cleaning Jira exports before sending them to the project manager. Now that's a 3-minute Cowork task."
Going through this course properly — not skimming, but actually working through each section with real tasks — changed something fundamental about how I think about my workday. The shift isn't "I now use AI for more tasks." It's subtler than that.
The real change is in what I consider worth my attention. The mechanical work — formatting data, deploying prototypes, renaming files, restructuring documents — none of that feels like something I should be doing anymore. Cowork handles it. That frees up cognitive space for the things that actually require a developer's judgment: architecture decisions, system design, code review, client conversations.
If you're a developer who's been using Claude occasionally and wondering why it isn't transforming your workflow — the answer is almost certainly that you haven't set up Projects, haven't written Skills, and haven't configured Cowork. Once those three things are in place, you're not using Claude. You're working with it.
Drop a comment below — I'm especially curious which Cowork workflow surprised you most, and whether you're using Projects for solo work or with a team. Let's compare notes.