Handling Projects with Claude
Scope a project, plan tasks with dependencies, find the critical path and slack with a real program, and handle a change request with a number instead of a guess.
In this lesson you will
- Write a scope with inclusions, exclusions and checks
- Plan tasks with dependencies
- Find the critical path and slack
- Handle a change request with a number
About 25 minutes
Meera promises a help centre in three weeks
A local shop asks Meera to build a small help centre: forty questions and answers about orders, delivery and returns. She plans to use Claude for first drafts. She agrees a date with the owner without writing a plan. Halfway through, the owner adds another section, and Meera realises she has no idea whether the date still holds. Projects with AI are still projects. The tool speeds up some tasks, but the dependencies, the reviews and the changes are just as real as before. This lesson is about scoping, scheduling, reviewing and handling change.
Scope first
- What is included. Forty questions, one tone, two rounds of changes.
- What is not. Translation, photos, anything about prices. Write it down.
- What you need from them. The policies, the source documents, one named person who approves.
- How you will check. Every answer is compared with the shop’s policy documents, and the owner signs off.
- What happens when things change. New requests get a new estimate before any work starts.
Plan with dependencies
Break the work into tasks with a number of days each, and say what each task waits for. Then find the critical path: the longest chain of tasks that must happen one after another, which sets the earliest possible finish. Tasks off that path have slack, which means they can slip a little without moving the end date. The program below plans Meera’s project. Notice that review is a task of its own, with its own time. AI drafting is quick, and checking is where the days go.
import numpy as np
TASKS = { # name: (days, depends on)
"scope": (1, []),
"collect": (2, ["scope"]),
"draft": (2, ["collect"]),
"review": (2, ["draft"]),
"fix": (1, ["review"]),
"design": (3, ["scope"]),
"assemble": (1, ["fix", "design"]),
"client review": (2, ["assemble"]),
"deliver": (1, ["client review"]),
}
def plan(tasks):
end = {}
def done(n):
if n not in end:
days, deps = tasks[n]
end[n] = max([done(d) for d in deps], default=0) + days
return end[n]
for n in tasks:
done(n)
total = max(end.values())
path, cur = [], max(end, key=end.get)
while cur:
path.append(cur)
deps = tasks[cur][1]
cur = max(deps, key=end.get) if deps else None
latest = {} # latest finish that keeps the total
def late(n):
if n not in latest:
after = [m for m in tasks if n in tasks[m][1]]
latest[n] = min([late(m) - tasks[m][0] for m in after], default=total)
return latest[n]
slack = {n: late(n) - end[n] for n in tasks}
return total, path[::-1], slack
def finish(total):
return str(np.busday_offset("2026-11-02", total - 1, roll="forward"))
total, path, slack = plan(TASKS)
print("days:", total, "finish:", finish(total))
print("critical path:", " > ".join(path))
print("design slack:", slack["design"], "days")
TASKS2 = dict(TASKS)
TASKS2["extra FAQ"] = (3, ["collect"])
TASKS2["review"] = (2, ["draft", "extra FAQ"])
total2, path2, slack2 = plan(TASKS2)
print("after change request:", total2, "days")
print("new finish:", finish(total2))
print("extra FAQ on critical path:", "extra FAQ" in path2)
print("draft slack now:", slack2["draft"], "day")
days: 12 finish: 2026-11-17
critical path: scope > collect > draft > review > fix > assemble > client review > deliver
design slack: 4 days
after change request: 13 days
new finish: 2026-11-18
extra FAQ on critical path: True
draft slack now: 1 day
The project takes 12 working days, finishing on 2026-11-17, if it starts on Monday 2 November. The critical path is scope > collect > draft > review > fix > assemble > client review > deliver. The design task is not on that path, and has 4 days of slack, so a small delay there would not matter, but a delay to drafting or review would move the finish. Then the change request arrives: an extra FAQ section that takes three days and must be done before review. The program re-plans. The project now takes 13 days and finishes on 2026-11-18. The new section is on the critical path, and drafting, which used to be critical on its own, now has only 1 day of slack. The honest reply to the client is a number: one new section adds one day, so the new date is 2026-11-18, and here is why.
Handle change calmly
- Write the request down and say what it would add.
- Re-plan before answering. Do not say yes first and find out later.
- Offer choices. Move the date, drop something else, or add cost.
- Get agreement in writing and update the plan.
- Keep the review time. When a deadline is tight, the first thing to cut is usually checking. Cut scope instead.
Planning the AI drafting time and forgetting the review time. A draft arrives in minutes, but reading it, correcting it and checking it against the source takes real hours. If it is not on the plan, it will be taken from your evenings.
Anthropic’s Projects feature, in the Claude app, can hold instructions and files for a piece of work so each chat starts with the same background. That helps with consistency, but it does not do the planning for you. Features differ by plan, so check the current help page.
Practice for this lesson
Check what you learned
Five quick questions. Pick an answer and you will see straight away whether it is right and why.
What is the critical path?
- The shortest task
- The most expensive task
- The first task
- The longest chain of dependent tasks
It is the chain that sets the earliest possible finish date.
What is slack?
- Wasted time
- Time a task can slip without moving the end date
- A type of review
- A fee
Tasks off the critical path have slack.
What should you do first when the client asks for more?
- Say yes straight away
- Ignore it
- Re-plan and work out what it adds
- Cancel the project
A number from the plan is a better answer than a guess.
Why keep review as its own task?
- Checking AI drafts takes real time
- It looks neat
- It is optional
- AI needs no checks
Drafting is quick but checking is where the days go.
What should you cut first when time is short?
- The checking
- The plan
- Scope, not the checking
- The client
Cutting checks risks errors reaching the client.
Summary
- Write what is in, what is out and how you will check.
- The critical path sets the finish; slack is spare time off it.
- Keep review as its own planned task.
- Re-plan before you answer a change request.
Questions
How long should review take compared with drafting?
It depends on the stakes and the material. For anything factual or public, plan real time to read, correct and verify every item, often more than the drafting itself.
Do I need code to make a plan like this?
No. A table of tasks, days and dependencies on paper or in a spreadsheet does the same job. The program just does the sums quickly.
Are the dates in the lesson real?
They are a worked example that assumes work days from Monday 2 November 2026 with no holidays. Use your own calendar.
