01 Astra is a new model — and a "model" is the brain behind the chat

When you open ChatGPT, you’re talking to a model. Think of the app as the service counter and the model as the person behind it. From time to time, the company replaces that person with someone more capable, and the counter stays the same.

GPT-6 Astra is the latest change. What changes for you isn’t a number in a table; it’s the speed and autonomy. Tasks that used to take half an hour of back-and-forth now take a few minutes, and Astra can work with programs and pages on its own. The rest of this lesson is about what to do with that.

For the accountant at a small firm, the front desk is still the same ChatGPT she opens every morning. The difference is that now the person behind the desk accepts requests like “put together and send a deadline reminder to the 12 clients on this list,” instead of just writing the reminder text.

02 Answering and doing are different requests

A request for an answer ends in chat: you get some text, and it’s up to you to use it. A task request ends outside chat: the result appears where it needs to be—the sent email, the updated page, the filled-in spreadsheet. The same sentence can be either, depending on how you finish the request.

Compare the accountant’s two requests. “Write a reminder about the August tax deadline” asks for an answer: she’ll still have to copy it, open 12 emails, and paste it in. “Send every client on this list a reminder about the 20th’s deadline, with their name and the payment slip amount, and show me the list of sent messages” asks for a task: when it’s done, the work is finished and she only has to check the list.

The practical rule: if your request ends with “tell me” or “write,” it’s an answer. If it ends with “do this there” and “show me proof,” it’s a task. Astra handles both; the change is for you to start making the second kind of request.

03 What it actually does today: works with programs, browses, and builds things

Three capabilities account for most of what you can delegate. It uses the browser the way you would: opens pages, clicks, fills things in, publishes. It works with files and programs on your computer: reorganizes a folder, edits a document, changes how a page looks. And it builds things from scratch when you ask: a short intro video, a comparison table, a simple page.

A freelance architect had a portfolio page that hadn’t been updated in two years. Instead of hiring someone, she asked: “make this page look more current and clean, keeping the photos and text that are already on it.” Within minutes, she had a new version to look at—not perfect, but ready for her to say what to change. The point isn’t perfection; it’s that the first version was ready without her opening an editing program.

04 What it still gets wrong — and why you’re still in control

Autonomy doesn’t mean infallibility. Two types of mistakes show up often. The first is getting a detail wrong: it publishes a notice with the product’s old name or uses the wrong date, with the same confidence it has when it gets things right. The second is generic taste: when you ask for something “beautiful” without giving it a reference, it delivers what looks like a template page, with nothing that feels like you.

Both have the same solution, and it’s your role from here on: check what was done before calling it finished, and provide enough context before making a request. The accountant who delegates sending 12 reminders still looks over the final list — she trades 40 minutes of typing for 2 minutes of checking. That’s the new job: judging, not executing.

05 Three tasks of yours to delegate this week

Use two questions to decide what to delegate. Is the task repetitive or mechanical — do you already know exactly how it should be done? And can you check the result in a few minutes by looking in one place? If the answer to both is yes, it’s a good first task. If the result requires your professional judgment on every line, it’s not time yet.

For the architect, three candidates: update the portfolio page with the two new projects; create a table comparing three flooring suppliers based on the PDF quotes; write and send a post-construction email to clients from this semester. For the accountant: send this month’s deadline reminders; organize a client’s receipts folder by month; create a table summarizing each client’s outstanding items.

You won’t learn to do Astra’s work. You’ll learn to make clear requests and review results quickly—and that’s what will make your time worthwhile.

01 It lives in your computer’s apps, not just on the website

Astra works best in the ChatGPT desktop app — the one you download once and keep on your Mac or Windows computer, with its own icon. That’s where the assistant can work with your programs and files. The website in your browser is for chatting, but not for delegating tasks that happen outside the chat.

If you already have the app, the first step is an update. Open the app menu, look for "Check for updates," accept, and let it reopen on its own. The new model arrives with that restart. If you don’t have the app yet, download it from the official ChatGPT website, in the apps section—it takes about 3 minutes.

The accountant had been using ChatGPT only in the browser for a year. When she heard about Astra, she checked the website and couldn’t find anything different. The model had been available on her account since launch day—she just needed to update the desktop app. That was the difference between “I didn’t get it” and “it was here the whole time.”

02 If it doesn’t show up, there are two places to check

The first place is your plan. Astra is available on paid plans — Plus and Pro. It won’t appear on a free account, no matter how much you refresh. The second place is the mode in the app: the regular chat, where you talk, and work mode, where the assistant performs tasks. Sometimes the new model appears in work mode first and only later in the regular chat.

This may seem complicated, but it works like two service counters at the same agency: the quick-service counter and the full-service counter. The new person may have started at the full-service counter. You just need to know both exist and check the other one if you can’t find what you need at the first.

The architect followed all four steps and found Astra only on the fourth. She had the right plan and the app was up to date; the model was simply at a different counter. Ten seconds after switching modes, it was there.

03 Pin your work conversation—or it’ll get lost among the others

When you delegate tasks, each one becomes a conversation, and conversations pile up quickly. The app lists them all in the left column, from newest to oldest. After a morning of work, the important conversation may be in tenth place, with a title you don’t recognize. It hasn’t disappeared; it’s just hard to find.

The habit that solves this is pin: hover over the conversation, click the three-dot menu, and choose “Pin.” It moves to the top of the list and stays there until you unpin it. Pin no more than three or four — pinning only helps if you do it sparingly. For the others, give them a name you’ll recognize using the same menu (“Rename”).

The accountant created a conversation for each major client and pinned the three she uses every week: “Silva — pending items,” “Padaria Real — deadlines,” and “Clínica — receipts.” When she opens the app, all three are at the top. She finds the rest by searching for the client’s name.

04 Ask the assistant itself: “What model are you?”

The safest way to confirm is the simplest. In a new conversation, write "What model are you?" and read the response. If it says GPT-6 Astra, it’s active. If it gives another name, you’re still using the previous model — go back to the four steps. Do this once every time you switch modes or after any update.

The architect spent an entire week requesting tasks, frustrated with how slow they were and with the results. Only at the end did she ask. The answer came with the old model’s name: an update had reset the selector to its default, and she hadn’t noticed. A five-word question would have saved the week.

01 A good request describes the destination, not the route

When you commission a bookcase from a carpenter, you don’t explain how to hold the saw. You say what you want finished, where it will go, and how you’ll know it turned out well. It’s the same with Astra. Describing every click treats the assistant like a hand that needs guiding; describing the result treats it like someone who knows how to work and needs to know what to deliver.

There’s a hidden benefit: when you describe the destination, it chooses the shortest path—which you often didn’t know about. A change that would require opening three screens can be done in one by the assistant. If you specify all three screens, it will follow your instructions and waste time.

The accountant wanted to change the footer text in 40 monthly reports. She started writing, “open the first file, go to the bottom of the page, select the text...” and stopped on the third line. She replaced it with: “In all the reports in the September folder, replace the old footer with this text without changing anything else, and show me the list of files you changed.” One request, 40 files.

02 The three parts of a delegable request: result, place, and proof

A delegable request has three parts, always in the same order. The result: what should exist when it’s done, described the way you’d describe it to a colleague. The place: where this happens — which folder, page, conversation, or app. The proof: what you want to see at the end to check it in a minute — a list, a screenshot, the link.

If the result is missing, it asks or makes one up. If the location is missing, it does the work in the wrong place with the same confidence. If the proof is missing, you have to go looking for what it did. Together, the three parts turn “it did something” into “it did this, here, and I saw it.”

03 The context it doesn’t have: attach the screen, file, or example

Astra can’t see what you see unless you show it. It doesn’t know which page you mean, which report you mean, or what "the way I like it" looks like. Three attachments solve almost everything: a screenshot (the screenshot of what you’re looking at), the file in question, and a example of a result you consider good.

The screenshot is the most underrated attachment. It shows the assistant exactly what’s in front of you — the open page, the table, the message — without your having to describe it. On Windows, press the Print Screen key; on Mac, press Command, Shift, and 4. The image is copied, and you paste it into the conversation.

The architect attached a screenshot of her current page and an example portfolio from a colleague she admired, and wrote: “Give mine this look, keeping my text.” The result had the right feel on the first try. Without the example, the same sentence would have produced the usual generic page — the subject of lesson 6.

04 One request, one task: how to break down something big

Requests that are too big fail in predictable ways: it does the half it understood and leaves the other half unfinished, or it does everything and you can’t check it. The measure is proof. If you can’t name a single piece of proof to check in one minute, the request is too big — split it into two, each with its own proof.

The accountant wanted to “close out Mr. Silva’s month.” That’s a morning’s work, not a request. She broke it into three tasks: organize the receipts by month (proof: the folder list), create a table of outstanding items (proof: the table), and write an email with the outstanding items (proof: the draft, not sent). Three requests, three one-minute checks, and the month closed before lunch.

05 When it asks for permission or stops halfway through, say "continue"

When working on programs or pages, Astra sometimes stops and asks if it can continue—open an app, sign in to an account, delete something. That’s a safeguard, not a flaw. Read what it’s asking; if it makes sense, reply “go ahead” or “continue.” At other times, it restarts a step and seems stuck: return to the same conversation and write “continue where you left off.”

The mistake is starting a new conversation and repeating the request. Then it starts from scratch, without what it had already done, and you’re left with two halves. The pinned conversation from lesson 2 is there for exactly this reason: that’s where the work is, and that’s where "continue" works.

The first time, the accountant was surprised when it stopped to ask if it could open the email program. She replied, “Go ahead, but drafts only, don’t send anything.” It followed her condition. The permission request became her chance to set a limit — which means more control, not less.

Describe what should exist at the end, say where, and ask for proof. It chooses the steps; you make the call.

01 "Use the computer" means seeing your screen and clicking the way you would

When the assistant uses the computer, it looks at the browser screen the way a person would, decides where to click, types, scrolls the page, and checks what appeared. It’s not magic or a secret shortcut: it’s the same sequence of actions you would take, carried out by the assistant while you watch. You see pages open and fields fill in in real time.

The important consequence: anything you can do on a page, it can do too — and anything you couldn’t do (an account you’re not logged into, a system that requires a code on your phone), it can’t do either. It inherits your access, no more and no less.

The accountant watches as the assistant logs into a client’s portal to download that month’s forms. She sees the login page, the menu open, and the files saved to the right folder. If anything looks wrong, she stops it. The first time, she watched everything. By the tenth time, she checked only the evidence.

02 Connecting: the Chrome extension and linking it to the app

For the assistant to see your browser, it needs a extension in Chrome. This may sound technical, but it works like a new outlet on the wall: you plug it in once, then just switch what’s connected on and off. The extension is the outlet; the ChatGPT app is the device.

The architect tested it with a flooring supplier’s website: “Open this supplier’s page and tell me the three cheapest floors per square meter.” She watched the tab open on its own, the page scroll, and the answer arrive with the prices. That was enough for her to trust the next step.

03 The task that ends outside the chat: fill out, prepare, publish

With the browser connected, the request from lesson 3 has a new destination: the result now exists on a page, not in the conversation. A notice posted in the client group, a system form filled out, an email prepared. The request structure doesn’t change—result, location, proof—but now the proof is a screenshot of where the work ended up.

The golden rule for getting started: ask drafts, not sending. "Prepare the email and save it in drafts without sending." "Write the notice in the publishing box and show me the screen before publishing." The assistant does 95% of the work, and the final click is still yours. After a few weeks of worry-free review, you decide what to allow.

The accountant asked: “In my email, prepare a message for each client on this list about the deadline on the 20th, with each person’s name and filing amount, and leave them all as drafts. Show me a screenshot of the drafts folder at the end.” Twelve drafts in three minutes. She opened two at random, checked the name and amount, and sent them all with one click each.

04 Always check: the case of the notice with the wrong name

A real case from the launch sums up the risk. Someone asked the assistant to post a notice about a new GPT-6 training in a customer group. It opened the group, wrote a good message, and posted it—and the message said “GPT-5.” Everything was right except the detail that was the whole reason for the notice. The person only noticed later, when looking at the group.

The mistake doesn’t erase the benefit: the notice was written and published in one minute. But it shows why "publish" without "show me first" is an unnecessary risk at the beginning. Three things to check in every task that comes out of the chat: the name (of the product, client, or person), the date or value, e o destination (the right group, the right email, the right page).

The architect applies the same standard to the construction notice it prepares for the condo association: she checks the building’s name, the start date, and whether the draft is in the right property manager’s email. Only then does she click Send. Thirty seconds that prevent weeks of embarrassment.

01 The first version is rarely the final one—and that’s normal

When you commission a project, the first sketch is a proposal, not the final delivery. It’s the same with the assistant: the first version is there for you to look at and react to. Expecting it to be finished is the wrong expectation; what it delivers quickly is the first version in minutes, and what you deliver is your judgment about it.

This changes how you think about time. Before, an afternoon of work produced one version. Now, ten minutes produce three—and the third is usually the good one. The skill isn’t getting it right the first time; it’s responding well between one version and the next.

The architect asked the assistant to make the firm’s project map “prettier and more useful.” The first version was darker, had less information, and was clearly worse than the old one. She nearly gave up right there. Instead, she looked it over, noted what had gotten worse, and asked again. The second version was better than the original.

02 "Make it prettier" is vague—say what got worse

A good request for a new version has the same structure as a task request: point out the specific problem, say what to keep, and ask for proof. “Make it prettier” doesn’t point to anything. “It got darker and lost the project names; keep the old color scheme and bring the names back” points out two problems and one thing to preserve.

The formula is to compare the new version with the previous one using three questions: what got worse? what got better and should stay? what’s still missing? The answers become the request. Without a comparison, you react to the new version without context, and the request ends up vague again.

03 Undo: ask to restore the previous version

When the new version turns out worse and you don’t want to keep trying, there’s a simple option: “Restore the previous version.” The assistant saves what it did at each stage of a conversation and knows how to go back to how things were before the last request. This applies to a page, a document, a table — anything it changed at your request.

Think of a version like a stored clipboard: the new one doesn’t erase the old one; it just goes on top. Knowing this takes away the fear of asking for bold changes. The worst case is saying “put it back the way it was” and losing two minutes.

The accountant asked for a complete reorganization of the client tracking spreadsheet. The new version was logical, but she couldn’t find her way around it anymore. “Restore the previous version and make just one change: separate active and inactive clients into tabs.” She got what she needed without losing the spreadsheet she knew.

04 Test a bold idea without ruining what already works

Sometimes you want to try something radical—a completely different page, a new report format—but you don’t want to risk what’s currently in use. The way to do it is to ask for a draft copy: “Make a copy of this page and, only on the copy, try a completely different look. Leave the original as it is.” If you like it, ask to apply it to the original. If not, delete the copy.

That’s what an office does with a project in progress: the approved version stays in the drawer while the experiment happens on a separate drawing board. With the assistant, that takes one sentence. The rule is: small change, make it in the original with “restore” as a safety net; big change, make it in a copy.

It’s easy to make bold requests when undoing them takes one sentence. The courage isn’t in the idea; it’s in knowing nothing will be lost.

The architect wanted to try a portfolio with large photos and no text. She asked for it on a copy, looked at it for two days, and decided she preferred the original with two larger photos. She applied only that change. The bold idea led to a small, safe improvement without a week of a broken page.

05 The whole cycle: ask, review, name, ask again

Putting it all together, the iteration cycle has four steps that repeat until you approve. Ask the version with the result, location, and proof. Look the proof, comparing it with the previous version. Naming what got worse, what turned out well, and what’s missing. Ask again with these three answers—or restore the previous version if the round wasn’t worth it.

Three rounds are usually enough. If you still haven’t approved it by the fourth, the problem is almost always a lack of reference—the assistant doesn’t know what you like. That’s the subject of the next lesson, and it’s what turns three rounds into one.

The accountant applied the cycle to her monthly report template: she asked, looked, pointed out issues (“the font is too small, the totals disappeared”), and asked again. On the third round, she approved it and asked to apply it to all 40 reports in the folder. The architect did the same with her portfolio page. Two professions, the same cycle — only what each checks in the evidence changes.

01 From scratch, it gives you the “generic” version—and that’s not a flaw

When your request doesn’t include any reference for what you like, the assistant does what any professional would do without a brief: delivers the average of what tends to appeal to people. A website page redesigned from scratch comes out correct but bland, like a thousand others. That’s not laziness or a limitation; it’s the absence of information that only you have.

Imagine a talented new employee on their first day. If you ask them to “put together a nice presentation,” they’ll make a nice presentation — according to their taste, which isn’t yours. The assistant is that employee; every day is the first day, and the only way it can match your taste is if you tell it.

The architect asked the assistant for a new version of the firm’s website without providing a reference. She got a dark, minimalist, technically flawless page that was completely different from her work, which is bright, full of wood, and lit by natural light. She discarded the version and correctly concluded that the problem was with the request.

02 One example is worth more than ten adjectives

"Elegant," "modern," and "welcoming" mean different things to everyone. An example doesn’t: a page by someone you admire, a report you found clear, an email you saved as a template. When you attach the example and say "with this feel, keeping my content," the assistant has something concrete to imitate instead of an adjective to interpret.

Two examples are enough, and it’s best if they’re different from each other: one shows the tone, the other shows the format. More than three gets confusing because it tries to please everyone at once. Also say what you admire about each one, in a single line—“I like the white space in this one” or “I like how this one sums things up in three sentences.”

03 The style guide: 5 rules you repeat all the time

Beyond examples, there are things you know about your work that you repeat in every correction: “never use red,” “always sign with your full name,” “short titles,” “talk about yourself, never about us.” That’s a style guide. It doesn’t need to be pretty or long: one page, with 2 examples, 5 rules for what to do, and 3 things never to do.

Write the rules as you’d tell a new coworker, not like a manual. “Always highlight the monthly total at the top” is a rule. “Prioritize the visual hierarchy of financial information” is a manual—and the assistant understands the first one better because it’s what you’d actually do.

04 Save and reuse it: the guide becomes a document you can attach

The guide only works if it’s always within reach. Save it as a simple document — a text file or a document in the editor you already use — with a name you’ll recognize: "style guide — office". From then on, every task request involving appearance or tone starts with "follow the attached guide." You don’t rewrite the rules; you attach them.

Over time, the guide grows. Every time you have to correct the assistant a second time about the same thing, that’s a sign a rule is missing: add a line. The guide becomes a record of your taste—and starts working for other people or assistants who work with you, too.

The accountant has two guides: one for appearance (reports and tables) and one for tone (emails and client notices: “courteous, direct, no jargon, always bold the deadline”). When she requests a notice, she attaches the tone guide. When she requests a report, she attaches the appearance guide. Each fits on one page and grew out of the corrections she got tired of repeating.

05 When it knows what you like, one try is worth ten

Put the two lessons together: the iteration cycle from lesson 5 still applies, but with the guide, it starts closer to the finish. The first version already follows the rules that matter to you; the next round, if there is one, fine-tunes details instead of redoing the direction. The time you spent explaining things again becomes time spent evaluating.

There’s one honest limitation: the guide doesn’t replace checking the work. It gets the style right, not the facts. Name, date, amount, and destination still need the three checks from lesson 4. The guide cuts down on rounds of visual tweaks; checking still protects the content.

The assistant can’t guess what you like. It imitates what you show it and follows what you write — once, on a page.

The architect and the accountant now share the same habit: task request, guide attached, evidence at the end. For one, the guide covers photos and tones; for the other, totals and deadlines. The process is identical, and it’s what makes the first version feel like it was made by someone who knows them.

01 Usage comes from a weekly allowance — and it goes down fast

Your subscription doesn’t give you unlimited use of Astra. It gives you a quota: an amount of work per week that renews on a set day. Each task it performs uses up a portion, and big tasks — changing an entire page, making a video, reorganizing a folder with dozens of files — use up big portions. It works like a book of vouchers: each request uses one, and the book is full again on renewal day.

An honest reference from the launch: one 40-minute morning of demanding tasks used about a quarter of the weekly quota. At that pace, the entire quota would last less than three hours of intense work. That’s not a reason to use less; it’s a reason to choose where to use it.

The accountant started the week by asking Astra to completely reorganize three client folders, each with hundreds of files. By Tuesday afternoon, the meter showed just over half remaining. She hadn’t done anything wrong — she’d spent her quota on three tasks a simpler model could do just as well.

02 Where to look: the usage meter and its renewal date

The app shows a usage meter in your account area: a bar or percentage showing how much you have left for the week, and the date your quota renews. Some plans also have an extra reserve you can use when the main quota runs out — a kind of smaller second ledger. Check the meter once a day, at the start of work, the way you check the fuel before heading out.

This may look like a control panel, but it’s just two numbers: how much is left and when it resets. With those two, the math is simple. If you’ve already used half by Tuesday, your current pace will use it all up by Thursday. If you want to make it to Friday, move Wednesday and Thursday’s heavy tasks to another model or wait for the reset.

The architect writes down both numbers in a corner of her planner every morning: “60% left, renews Saturday.” Within two weeks, she could predict without checking whether the task she was about to request would fit within her quota. The prediction matters more than the number: it’s what helps her decide what to do today and what to leave for later.

03 Not every task needs the best model

The same subscription includes other models that are simpler and cost less toward your quota. They do a great job on work that doesn’t require judgment across several steps: drafting a notice using your tone guide, renaming files according to a clear rule, summarizing a document, answering a direct question. Using Astra for that is like asking the senior partner to staple papers.

Use the same yardstick as in lesson 1, applied to the model. Does the task require understanding multiple screens, making decisions along the way, working in programs, or building something from scratch? Astra. Is it a clear rule applied many times, or text based on a guide? Regular model. If you’re unsure, start with the regular model: if the result is weak, switch to Astra in the same conversation.

04 Orchestrate: the expensive one plans, the cheap one executes

There’s a step beyond choosing the model for each task: asking Astra itself to distribute the work. It’s called orchestrate: Astra plans the work, breaks it into parts, and sends the mechanical parts to a regular model, while handling coordination and the final review. You pay for Astra’s quota only for planning; repetitive execution is cheap.

That’s what an office does with a large project: the senior professional sets the direction and reviews the work; the team draws the plans. With the assistant, you can fit that into one sentence in your request: “Plan this task, handle the repetitive parts with a simpler model, and bring me the checked result.” It understands the request and organizes the work that way.

Use the best model to make decisions, not to repeat them. Repetitive work can use a simpler one—and your quota will last until Friday.

The architect asked: “Plan the portfolio update with the 8 new projects. Define the template for each profile with Astra, generate the 8 profiles with a simpler model following the template, and show me all 8 side by side so I can review them.” Planning used little quota; the 8 profiles used almost none. Her review took five minutes.

05 A shared memory: notes all your assistants can read

One real limitation of assistants today: each conversation knows little about the others, and different assistants know nothing about one another. If you use Astra for one part of your work and another assistant for something else, each starts from scratch. The solution is simple and old: a notes folder yours, in regular text files that you attach or point to in every request — the style guide from lesson 6 is its first resident.

Put in this folder the things you’re tired of explaining: the style guide, the client list with each person’s preferences, the year’s fixed deadlines, and the way you name files. Note-taking tools like Obsidian work well because they store everything in plain text that any assistant can read. But a regular folder with text files will do the job too.

The accountant has a folder called “office memory” with four files: a tone guide, an appearance guide, a deadline calendar, and client profiles. Every request starts with “read the office memory folder first.” Astra, the regular model, and any future assistant all start from the same place—and she never has to explain the same deadline twice again.

01 Recipes and connections: what expands what it can do

The assistant gains new capabilities in two ways. The first is a recipe: an instruction document that teaches a way of working — “this is how you put together a short presentation video.” The second is a connection: a connection to a program already on your computer, through which it operates that program as if it were using the keyboard.

This may seem like a programmer’s thing, but it works like a professional’s toolbox: the recipe is the instructions for a technique; the connection is the tool itself. You don’t need to know how to build either one. You need to know they exist, ask it to use them, and—when it suggests finding a new recipe online—ask it to check where it came from before using it.

The architect discovered the difference when she asked for “a 30-second video introducing the firm.” The assistant said it would need a video recipe and asked if it could activate one. She replied, “Go ahead, and tell me where it comes from.” It activated it, explained its source, and the video was ready minutes later.

02 An intro video with one request

The most useful example for most offices is a short video: 30 seconds introducing the service, with on-screen text, transitions, and background music. There’s a free recipe for this called Remotion, which the assistant activates and uses. You don’t open a video editor. Describe the video as you would to someone who was going to make it, and you’ll get a file ready to publish.

The accountant asked for a 30-second video for the start of the year: “four deadlines every small business needs to know.” The firm’s name at the beginning, four dates on screen, the guide’s sober tone, and the contact details at the end. She posted it on the firm’s profile that same day. She had never opened a video editor, and still hasn’t.

03 3D objects: when it operates an entire program on its own

The most impressive launch example was 3D. With a connection to a free modeling program called Blender, the assistant builds objects and scenes in three dimensions from a description — and can even build a simple game, with a track, car, and sound, in a single request. It opens the program, models, adjusts, and tests for about twenty minutes, without anyone touching the keyboard.

This isn’t for everyone, and that’s okay. Ask yourself: "In my work, is there something I design, assemble, or represent today that a program could do better?" If so, there’s probably a connection for that program. If not, you don’t need this part—the toolbox approach still applies to spreadsheets, word processors, and browsers.

For the architect, the answer was yes: she asked for “a simple 3D model of this floor plan, with the walls and openings, so I can show the client where the morning light comes in.” Twenty minutes later, she had a scene she could rotate on screen. For the accountant, the answer was no — the program she needs it to operate is the spreadsheet, and it already has that connection.

04 Long tasks: let them run, say “continue,” check at the end

Tasks with extra tools usually take ten to thirty minutes, and the assistant works on its own during that time. You don’t need to watch. Leave the conversation open, do something else, and come back. Two behaviors are normal and don’t mean there’s an error: it may ask permission to open or restart a program, or it may stop after a restart as if it had forgotten what it was doing.

In both cases, the response is short. For permission: read it and reply "go ahead." If it stops: return to the same conversation and write "continue where you left off." It picks up where it was. Don’t do what lesson 3 already warned you about: start a new conversation and repeat the request, because then twenty minutes of work starts over from scratch.

The accountant left the assistant working on an annual deadline spreadsheet through a spreadsheet connection, went to a meeting, and came back 25 minutes later. A permission request was waiting. She replied, “Go ahead,” and it finished in three minutes. Then she checked the evidence: the spreadsheet, with all 48 dates for the year across four tabs.