Claude Code Tasks: When Claude Code Plans the Work (and Then Does It)

Barely noticed, Claude Code replaced the simple to-do lists it used to generate with a more structured Tasks feature. And nothing showcases agentic coding better than that shift: Tasks turn “here’s what I’ll do” into an executable plan with dependencies, sequencing, and parallelizable workstreams.

Here’s a simple example. I start with the prompt below:

Create the tasks for website for a company called Uberhamster who specialize in overnight boarding of hamsters. There should be a landing page, a page where clients can make reservations for boarding their hamster(s), a pricing page, a gallery of hamster images, and a FAQ page.    

The task list created by Claude Code was as follows:

 1. Set up project structure - Create the file and folder structure
 2. Create landing page - Build the main homepage with hero section and CTAs    
 3. Create reservations page - Build the booking form for hamster boarding   
 4. Create pricing page - Display boarding rates and packages 
 5. Create gallery page - Showcase hamster images in a responsive grid
 6. Create FAQ page - Answer common questions about the service  
 7. Implement site-wide styling - Add consistent CSS styling across all pages  
 8. Test and validate website - Final testing and quality checks 

                             

This would deliver an MVP (Minimum Viable Product) website—but let’s push it a step further by making reservations persistent. That means designing and implementing a database and moving from a front-end–only build to a simple two-tier architecture: a web front end backed by a database.

So I added the prompt below:

Add a tasks for the design and coding a database so that the reservations can be persisted.

The following 4 tasks were added: 
 
9. Design database schema - Design tables for customers, hamsters, and reservations with proper relationships 
                                       
10. Set up database - Implement the database with initialization scripts andconfiguration    
                                                             
11. Create backend API - Build REST API endpoints for CRUD operations on reservations 
                                                                 
12. Integrate reservation form with backend - Connect the frontend form to the API for data persistence    
                                               

Here’s where it gets interesting: some of this work can happen in parallel, while other pieces can’t even start until prerequisites are finished. In the past, Claude Code would respond with a simple to-do list. Tasks are more sophisticated—they capture the actual execution plan, including dependencies and sequencing, so the work can be implemented in the right order while still taking advantage of parallelism where it makes sense.

set up task dependencies 

Here is how Claude Code responded to this prompt:

Task dependencies have been set up. Here's the execution flow:                                                                                              

  Phase 1 - Foundation:  
 
  - Task #1 (Set up project structure) → Unblocks tasks #2-6                                                                                                                                                   

  Phase 2 - Content Creation (parallel tracks): 
 
  - Frontend Track: Tasks #2, #3, #4, #5, #6 (all pages) → Unblock task #7
  - Backend Track: Task #9 (Design schema) → Task #10 (Setup database) → Task  #11 (Create API)                                                                                                                                                                   

  Phase 3 - Integration:  

- Task #7 (Styling) - requires all pages complete
- Task #12 (Form integration) - requires task #3 (reservations page) and #11  (backend API                                                                                                                                                                                                                                                  

  Phase 4 - Final:   

  - Task #8 (Testing) - requires task #7 (styling) and #12 (integration) to be  complete                                                                              

This ensures that the project structure is built first, then pages and database work can happen in parallel, followed by styling and backend integration, and finally comprehensive testing.

All that remained to be done was to start the implementation with this prompt:

start implementation of tasks   

Claude Code worked through these tasks and after 6 minutes and 30 seconds I had a working website with documentation on how to run it. The final message was this:

 🚀 To Run the Project:                                                        
                                                                                
  1. Initialize the database:                                                   
  python database/setup.py  
                                                    
  2. Install backend dependencies:                                              
  pip install -r backend/requirements.txt
                                       
  3. Start the API server:                                                      
  python backend/app.py 
                                                        
  4. Open the website:                                                          
    - Open index.html in your browser, or                                       
    - Run python -m http.server 8000 and visit http://localhost:8000            
                                                                                
  The complete Uberhamster website is now ready with a working reservation      
  system, database persistence, and a professional user interface!              
                                                                                
✻ Brewed for 6m 30s 
                       
 🚀 To Run the Project:                                                                

Conclusion

I’ve said it before: the real milestone isn’t that Claude Code can generate a working website. It’s that we can hand it almost any piece of work, have it break the job into discrete tasks with dependencies, spot where work can run in parallel, and then let it move forward autonomously—or with a human in the loop.