The Complete ChatGPT + GPT-6 Astra Guide

A practical field guide from The AGI Guide · Updated September 2026

If you are still treating ChatGPT like a search box, you are leaving most of the product untouched. The useful question is not “What can I ask it?” It is “What outcome can I hand it, what context does it need, and how will I check the result?” This guide takes you from a first conversation to a repeatable workflow that produces something you can actually use.

I built this for the person who wants to make progress today. You do not need to memorize every model or master a clever prompt acronym. You need a clear path through Chat, Work, Codex, files, connected tools, and the new GPT-6 Astra model. I will show you where each belongs, give you prompts you can paste, and point out the moments when you should slow down and verify.

The five-minute route: Create an account, choose one real task, put relevant material in the conversation, describe the finished result, ask ChatGPT to show its work, and review the output. If the task needs several tools or a finished file, use Work. If it needs code or a repository, use Codex. Choose Astra for the hardest jobs where extra reasoning and judgment are worth the cost and time.

What you will leave with: a setup checklist, model decision guide, a reusable personal brief, 12 copy-and-paste prompts, a verification method, three complete workflows, a seven-day practice plan, and a clean link you can return to when a new feature launches.

1. Start with an outcome, not a feature tour

Most beginner guides walk through every button in the interface. That can help you get oriented, but buttons move. Outcomes do not. Before you open ChatGPT, write one sentence: “I want to finish ___ so I can ___.” The first blank is the deliverable; the second is why it matters. “Summarize this PDF” is vague. “Turn this 18-page proposal into a one-page decision brief for my team meeting tomorrow” tells the system what to make and how you will use it.

For your first task, pick something you already know enough about to judge. A meeting transcript, sales spreadsheet, draft email, research question, product page, or room photo works. Avoid a high-stakes legal, medical, or financial decision as your first experiment. The point is to learn the workflow while you can recognize mistakes.

Write down your input, output, and test. For a one-page brief, the input might be the original proposal; the output is a page with recommendation, evidence, risks, and open questions; the test is whether a colleague can make a decision from it without opening the proposal. That small test is more powerful than asking ChatGPT whether its own answer is good.

You can use this exact opener:

I want to finish [deliverable] for [audience] so they can [decision or action].
Use [attached files or named sources].
The result should include [must-have sections] and fit [length or format].
Flag assumptions and missing evidence. Before you start, ask only questions that would materially change the result.

That is enough for many jobs. You can refine after seeing a draft. The goal is a productive conversation, not a perfect first prompt.

2. Know which surface you are using

ChatGPT now offers several ways to work. Think of them as three starting points rather than three separate identities. Chat is for a quick answer, explanation, brainstorm, translation, rewrite, or decision support. Work is for a completed deliverable that may require several steps, sources, files, or tools. Codex is for software tasks: reading a codebase, editing files, running checks, and explaining the changes. The desktop app gives local Work and Codex access to projects and files on your machine; web or cloud Work can continue while your computer is away, depending on your plan and rollout.

Here is my rule. If you can judge the result in a minute and no file must be produced, start in Chat. If you would otherwise spend an hour gathering material and assembling a document, use Work. If the thing being changed is a website, script, app, or repository, use Codex. You can switch approaches when the task changes. A Chat conversation can help you frame a plan; Work can turn it into a deck; Codex can build the tool that makes the process repeatable.

Example: I want to make an AI tutorial. I use Chat to pressure-test the angle and find the beginner questions I missed. I use Work to research current official documentation and assemble a publishable guide. I use Codex to update The AGI Edge website, run the build, and check the live route. Those are different jobs even though they belong to one project.

If you use a phone, start with the same outcome sentence. Mobile is excellent for voice, quick capture, and reviewing a running task. When a workflow needs local files or a native app, move to desktop. When you need a task to keep running without your laptop, use the cloud option if it is available to you. Availability and usage limits can change by plan and workspace, so look at the controls shown in your own account instead of relying on a screenshot from someone else's.

Source: Get started with ChatGPT Work and Use ChatGPT.

3. Your first ten minutes of setup

Go to chatgpt.com, sign in, and try a plain conversation. Then install the desktop app if you want local projects, the built-in browser, or computer use. On a shared or managed computer, follow your organization's setup rules. On mobile, install the official ChatGPT app from your device's app store and sign in with the same account.

Next, make a short personal brief. Do not turn it into a biography. Include the work you do, your audience, what “good” sounds like, and what you want ChatGPT to ask before acting. Keep it practical and revisable. You can put durable preferences in personalization or custom instructions where available; keep task-specific facts in the task itself. A preference such as “write in plain English” travels well. A client deadline belongs in the current project.

I create practical AI tutorials for people who want a result they can copy.
My audience is curious but busy. Explain unfamiliar terms once, then show a concrete example.
Use a direct voice. Prefer steps, screenshots or examples, and clear tradeoffs over hype.
When a claim depends on a current feature, plan, price, or policy, verify it from an official source and link the source.
When you make a file or edit a site, tell me what changed and how you checked it.

That example reflects how I work at The AGI Guide. Replace the first two lines with your own job and audience. Test it on a real prompt; if the results become repetitive, shorten it. Good personalization removes repeated context without hijacking every answer.

Finally, create a folder or Project for a recurring topic. Put stable reference files there: brand voice, product facts, standard operating procedure, sample report, or dataset. Do not upload secrets to make an example work. Name files clearly, include dates where they matter, and remove stale versions. A good Project should tell a future version of you what material is authoritative.

4. GPT-6 Astra in plain English

GPT-6 Astra is OpenAI's most capable model for difficult end-to-end tasks, including complex reasoning, coding, research, computer use, and document creation. In the API, its model ID is gpt-6-astra, it supports a 1,050,000-token context window, and its supported reasoning efforts include low, medium, high, xhigh, and max. Those are API specifications, not a promise that every ChatGPT plan exposes every setting or lets you paste a million tokens into a chat. Your product controls, plan, and workspace govern what you can select.

Astra is part of a family with Sol and Luna. A simple mental model is: Astra for the hardest judgment-heavy job; Sol for strong everyday work; Luna for fast, focused tasks. Do not choose by prestige alone. If you need five title variations, a shorter model is likely enough. If you need a defensible comparison of 40 sources, a complicated spreadsheet, and a finished executive brief, Astra makes sense.

The model is only one lever. A strong brief, correct source material, and a clear verification step often matter more than moving the reasoning slider. I have seen people ask the best model to “make this better” and then blame it for guessing the audience. Tell it what “better” means. When the task is high stakes, spend your effort on source quality and review.

A practical selection loop: Start with the default model for a low-risk version of the task. Move to Sol when the answer needs more reasoning or the first pass misses dependencies. Use Astra when the task crosses tools, involves messy evidence, needs visual judgment, or has a real cost of error. If the model selector does not show a named model, use the best available option and focus on the workflow. Do not assume a missing option means your account is broken; rollouts and plan access vary.

Source: GPT-6 Astra model specification, GPT-6 model guidance, and ChatGPT Work guidance.

5. The prompt that works across Chat, Work, and Codex

A reusable prompt needs six pieces: outcome, audience, sources, constraints, process, and acceptance test. You do not need a mnemonic. Just state them. Outcome says what to produce. Audience says who will use it. Sources identify what to trust. Constraints bound length, style, and scope. Process says whether to ask, research, or create first. Acceptance test tells ChatGPT how you will decide that the task is done.

Outcome: Create [specific result].
Audience: [who will use it and what they need to decide].
Sources: Use [files, links, connected tools]. Treat [source] as authoritative.
Constraints: [length, tone, exclusions, deadline, format].
Process: Identify missing facts, do the work, and show me the result. Ask before consequential actions.
Acceptance test: I should be able to [checkable action] without [extra work].

For a research question, change the acceptance test to “I can click every citation and see the claim it supports.” For a spreadsheet, use “The totals reconcile with the raw data and formulas are visible.” For a site, use “The page loads on mobile, all links work, and the live URL matches the approved copy.” These tests force the task toward a real outcome.

Do not ask the model to “act as a genius” or write a giant roleplay preamble. Give it the evidence it needs. If you are unsure what to provide, ask: “What are the three facts that would most improve this result?” Then supply those facts and continue. Ask for a brief plan only when the task is complicated enough that you want to catch a wrong direction early.

When you correct it, state the correction plainly: “The audience is first-time founders, not enterprise buyers. Rework the examples and keep the core recommendation.” You do not have to restart from scratch. GPT-6 can incorporate new instructions during a longer task; make the change as soon as you see the issue.

6. Research without turning guesses into facts

ChatGPT can search the web, inspect supplied links, and compare sources. That is useful, but a fluent answer is not the same as a verified answer. For anything that changes over time—pricing, model access, regulations, product features, deadlines—ask it to check current sources. For a vendor's own product facts, start with that vendor's official documentation. For claims about outcomes, look for independent evidence and the conditions under which the result was measured.

I use a three-pass research workflow. First, collect the relevant official pages, original studies, product docs, or primary records. Second, extract each claim into a small table with source, date, and uncertainty. Third, write the narrative using only supported claims. That middle step catches the common mistake of finding one exciting page and writing a confident story around it.

Research [question] as of today. Start with official documentation and primary sources.
Make a claims table with: claim, direct source link, publication or update date, and confidence.
Separate documented facts from your inferences. If sources conflict, show the conflict.
Then write a plain-English answer for [audience].
Do not use a citation unless the linked page directly supports that sentence.

For this guide, I checked current OpenAI product and model documentation instead of copying the competitor's plan grid. Some price tables and usage caps change quickly; a guide that hard-codes them without a refresh process becomes stale. If you need to buy a plan, check the official pricing page and the plan picker in your account on the day you purchase. Keep API pricing separate from ChatGPT subscription pricing: they are different billing systems.

Deep Research is useful when you need a longer, multi-source investigation. Give it a bounded question and tell it what decision the research should inform. Ask for a source ledger and a short summary of what remains unknown. If the output is going into a public video, open the most important citations yourself before recording. The extra five minutes can save a correction later.

7. Files, data, and finished deliverables

The fastest way to improve a file task is to provide the original file and a sample of the result you want. “Analyze my spreadsheet” asks the model to choose a business question for you. “Find the three reasons revenue dropped between April and June; show the calculations and make a one-page chart” gives it a job. Tell it which columns are identifiers, which numbers are currency, whether blanks mean zero or unknown, and which rows to exclude.

For documents, specify the final artifact and reader. A board memo, customer email, FAQ, and internal notes should not sound alike. Ask for an outline if the source material is messy, then let Work create the file. Check the actual output, not just the chat summary. Open it. Make sure page breaks, table widths, formulas, fonts, and headings work. A generated file is a draft until you have inspected it.

Use the attached CSV to create a review-ready analysis.
First check row count, date range, duplicate IDs, missing values, and currency assumptions.
Then calculate monthly revenue, growth, and the top three contributors to change.
Create a spreadsheet with raw data, calculations, and a summary tab.
In your final note, list any rows you excluded and show how you verified the totals.

A useful general rule: ask for the source-of-truth trail. Where did each number come from? Which document supports each statement? What changed in the original file? If the answer cannot tell you, you have a review problem. This applies equally to a slide deck and a code patch.

When sensitive information is involved, use the smallest data sample that can answer the question. Redact personal details for demonstrations. Check your workspace's privacy and retention settings before uploading business documents. If you are working for someone else, their policy decides what may enter the tool.

8. Work: delegate an outcome, then inspect the work

ChatGPT Work is where I go when I want ChatGPT to complete a substantial task instead of simply advising me. It can work across sources and tools, produce a file, and manage a multi-step workflow. In the desktop app, local Work can use files and apps on your computer. Cloud Work, when available, can keep running after you close the app. The choice should follow where the data lives and whether the task needs local access.

A good Work request sounds like an assignment to a capable colleague. “Make a presentation” is under-specified. “Review these three interview transcripts, identify the five repeated pains, create a six-slide decision deck, and flag any claim supported by only one person” is reviewable. State what should happen before any external action. If the task could send messages, purchase something, or publish, say where you want a review point.

Create a publish-ready beginner guide for [topic] using the attached transcript and current official documentation.
Audience: people who have never used the feature.
Include a 10-minute setup, three worked examples, common failure fixes, and a one-page checklist.
Cite time-sensitive claims inline. Keep my direct, practical voice.
Return the document and a short list of facts I should verify on camera.
Stop before publishing.

You can steer Work while it runs. If you notice a wrong audience or a missing source, send the correction then. When it finishes, review the file and ask targeted follow-ups: “The setup section assumes a paid plan; rewrite it for a free user,” or “The chart title says users but the data is sessions; fix the label.” Do not ask for “more polished” if you can name the issue.

For a repeat task, keep the successful prompt and the source locations together. That gives you the foundation for an automation later. A good manual run is the test case; scheduling an untested prompt only repeats its mistakes.

Source: Get started with ChatGPT Work.

9. Codex: the path from idea to working software

Codex is built for code and repositories. It can inspect a project, edit files, run commands, and report what changed. A beginner can use it without knowing every framework detail, but you still need to tell it the product behavior you want. “Build me an app” leaves many decisions open. “Create a mobile-friendly page where users paste a URL, see a summary, and copy a checklist” is concrete.

Start with a small task in a real project. Ask Codex to inspect the code and explain the relevant files before changing anything when you are unfamiliar with the repository. Then ask it to implement the result, run the right checks, and tell you what remains uncertain. Review the working page or test output. A green build tells you the code compiles; it does not prove the user flow is good.

In this repository, add [feature] for [user].
The user should be able to [three observable actions].
Follow the existing design and data patterns. Preserve current behavior.
Run the relevant build or tests, then tell me what changed, what you verified, and what I should review in the UI.

Astra is useful when the job requires understanding a broad codebase, migrating a difficult system, or coordinating code, research, and visual review. Sol is often enough for a contained fix. If a change goes live, ask for the exact route and verify it after deployment. Keep the code and the published version in sync; a local preview is not the same as a live update.

This is also where The AGI Edge fits into my own workflow. A tutorial becomes much more useful when viewers can open a stable resource page, copy the prompts, and return to updated instructions later. The page is an artifact. The automation that sends it to viewers is a separate distribution step. Build and check the artifact first.

Source: OpenAI's code generation and Codex guide.

10. Browser, computer use, and plugins

There are two different kinds of “ChatGPT used a browser.” ChatGPT Work in the cloud can use its own browser to work through websites, including sign-in flows when supported. In the desktop app, Computer Use can operate supported native apps and browsers on your machine after you enable the plugin and grant the required permissions. The distinction matters: cloud browsing does not mean it can see a file sitting in a folder on your laptop, and local computer use depends on your machine being available.

Give browser tasks a destination and a verification rule. “Find a flight” could mean a dozen different things. “Compare nonstop flights arriving before 6 p.m. on these dates; return a table with total price and baggage rules; stop before booking” is scoped. For a site update, say which site and which page to edit, what must be preserved, and how you will recognize the published result.

Plugins connect ChatGPT to services and reusable workflows. Install only what your task needs. If you want it to use a connected Drive folder, name the folder and ask it to cite the files used. If you want a message drafted, distinguish drafting from sending. If you want a calendar change, provide the timezone and participants. Check the permission screen so you know the scope of access.

Use my connected [service] to find [specific records] from [date range].
Read only. Return a source-linked summary and identify anything missing.
Do not send, change, delete, or publish anything.

That last line is useful when you are exploring a connector for the first time. Once you have checked the read-only result, you can give a narrower instruction to make the change. Do not paste passwords into a chat. Use the product's sign-in flow when an authenticated website is required.

Sources: Browser, Computer Use, and Plugins.

11. Projects, memory, skills, and scheduled tasks

These four features solve different problems. A Project groups conversations and reference material for a topic. Memory carries useful personal context, subject to your settings. A skill is a reusable instruction set for a specialized workflow. A scheduled task runs or revisits work at a chosen time or supported event. The order I recommend is: succeed manually, collect stable context, then automate.

For a Project, include only files that should influence future answers. If you keep ten conflicting “final” brand guides, the model cannot know which one to trust. Add a short project note saying which file is authoritative and when it was last reviewed. For memory, review what is saved and remove facts that are wrong or too personal. For a skill, write instructions around a repeated workflow that has clear inputs and outputs, such as “turn a transcript into a source-checked tutorial outline.”

Scheduled tasks are most useful when the work has a natural cadence or trigger. A weekly research roundup, a Monday planning brief, or a check for changes to a product document has a clear job. A schedule will not fix vague instructions or inaccessible sources. Test one manual run, review the output, then choose timing and notifications. If the task uses local project files, the desktop app and computer must be available; web scheduled tasks cannot reach a local folder directly.

Here is a future-ready automation brief for a tutorial resource. It is intentionally a brief, not a live automation:

Trigger: viewer comments the chosen keyword on the matching video.
Destination: send the public resource URL for this guide.
Message: one sentence explaining what is inside, then the link.
Checks: only trigger for the intended post, avoid duplicate sends, test with a private account, and confirm the link opens on mobile without sign-in.
Source URL: https://theagiedge.com/resources/complete-chatgpt-gpt6-astra

When you are ready to configure distribution, you can use that stable URL and choose the exact video, keyword, and message. There is no reason to turn on the automation before the guide and its public access are confirmed.

Source: Scheduled tasks.

12. Images, voice, and visual work

Image generation is useful for moodboards, concept art, thumbnails, product scenes, and explaining ideas visually. The important step is telling ChatGPT what should be visually true: subject, camera angle, lighting, composition, aspect ratio, and what must be legible. If you provide a reference image, specify what to preserve and what to change. Review any text inside a generated image letter by letter before publishing; beautiful typography can still be wrong.

For edits, work in passes. First lock the composition, then change one variable at a time. “Make it premium” is hard to judge. “Keep the subject and crop; replace the blue background with warm cream and increase headline contrast” is clear. Save the chosen version and record the prompt that made it, so a later revision has an actual starting point.

Voice is valuable when typing would break your momentum. Use it to talk through a problem, practice a presentation, or capture a rough idea. Then ask for a structured summary and check the names, numbers, and commitments in the transcript. Spoken thoughts are often exploratory; tell ChatGPT which ideas are decisions and which were merely possibilities.

I am going to talk through an idea for five minutes.
Do not interrupt except to clarify a number or name.
Afterward, return: the core idea, assumptions, open questions, next three actions, and a 30-second explanation I could say on camera.
Mark anything you are unsure you heard correctly.

For a video tutorial, I would use voice to sharpen the opening, Work to research and draft, image tools for supporting visuals, and Codex to publish the companion resource. Each tool earns its place by producing a better artifact. The workflow should still make sense to a viewer who only wants the written steps.

13. Three complete workflows you can copy

Workflow A: Turn a messy meeting into decisions. Input: transcript or notes. Start in Chat if the meeting is short; use Work if you need a finished memo or follow-up file. Ask it to separate decisions, owners, deadlines, and unresolved questions. Make it quote the line of the source that supports each commitment. Read the original around any deadline or person’s name. Then use your connected tool to draft follow-ups, but review them before sending. The result is a clean decision log rather than a generic summary.

Turn these meeting notes into a decision log.
For each decision, include owner, due date, evidence from the notes, and any dependency.
Separate proposals from decisions. If an owner or date is missing, write “not assigned.”
Draft a short follow-up message, but do not send it.

Workflow B: Research a purchase without a fake certainty. Input: budget, must-haves, current prices, and the date you need to buy. Ask for a shortlist from current sources, a comparison table, and a recommendation with tradeoffs. Require links to the exact product pages and current price. Check shipping, returns, and compatibility yourself before paying. If the model has too many possible options, narrow the request by your actual constraint: space, battery life, camera type, or team size.

I need [product] for [use] and my maximum all-in budget is [amount].
Compare three current options from primary product pages.
Show price, the two specs that matter for my use, one drawback, and return policy link.
Recommend one and explain when another option would be better.
Do not purchase anything.

Workflow C: Publish a tutorial companion. Input: video transcript, target audience, demo assets, and the claims that need checking. Work researches official documentation and drafts the guide. Chat pressure-tests whether a beginner can follow the first ten minutes. Codex adds the page to your site, checks build output, and verifies the live route. The final QA is human: open the page on a phone, tap the copy buttons, read the prompts, and make sure the call to action matches the video. Only then connect the comment-to-DM automation.

Use my video transcript to produce a standalone companion guide.
Keep every promised step, add the exact copy-and-paste prompts, and explain the failures a beginner will hit.
Verify current product claims from official pages.
Make the first screen useful to someone who clicked from the video.
Return the public URL only after the page is live and checked.

The common pattern is visible: start from an input you trust, define a finished artifact, ask for evidence, and check the result in the place it will be used. That pattern is more durable than any one product feature.

14. The verification loop that catches most mistakes

Before you trust a result, run five checks. Facts: open the primary links behind time-sensitive claims. Numbers: recompute one or two totals and check units. Names: verify people, companies, URLs, and dates. Format: open the actual file or page at the size your audience will use. Action: check that the requested action is really complete, not merely described as complete.

Ask ChatGPT to help with verification, but do not let it be the only verifier of its own work. “Check this” may produce a reassuring paragraph. “Recalculate the total from these rows and show the arithmetic” is a test. “Open each cited source and quote the line supporting this claim” is a test. “Load the live URL and compare its title, first paragraph, and links with the approved copy” is a test.

Keep an error log for repeated tasks. Note the input, model, instruction, failure, and fix. If the same failure appears three times, improve the source material or the workflow instead of adding another sentence to a giant prompt. Maybe the spreadsheet column name is ambiguous. Maybe the brand guide contradicts itself. Maybe the verification step is too subjective. Fix the cause.

A finished response should tell you what was done, where the result is, how it was checked, and any material limitation. “Done” without a file or URL is not a useful handoff. If a tool could not access a source, a build failed, or the result depends on an assumption, that belongs in the final note.

For public content, add one extra pass: read it aloud. Awkward explanations reveal themselves quickly. If you stumble on a sentence, your viewer will too. Replace jargon with the task it describes. Explain “context window” as the amount of material a model can consider at once before diving into token counts.

15. Privacy and safety choices that actually matter

Start by deciding what data is necessary. A product comparison rarely needs your home address. A spreadsheet analysis may not need customer names. A tutorial demo should use synthetic or redacted data. Minimum necessary input is a good habit because it makes prompts clearer as well as safer.

Review your data controls, memory settings, connected services, and sharing settings in the product you use. Individual and organization plans can have different policies. If you work under an employer or client, follow their approved tool list and data handling rules. For sensitive decisions, use ChatGPT to organize questions and evidence, then involve the appropriate qualified person before acting.

Computer use and plugins can affect state outside a chat. Use explicit boundaries on the first run: read only, draft only, or stop before sending. Check the domain on a sign-in screen. Use the secure product sign-in flow rather than typing passwords into a prompt. When a task asks to publish, pay, delete, or message someone, inspect the proposed action and the exact destination.

When sharing a ChatGPT conversation, remember that the conversation may include context you did not intend to publish. Share the final artifact when possible. If you need to share a chat, scan it for personal data, source links, uploaded content, and internal comments. For a public tutorial, rebuild the example with safe demo material.

These are practical controls, not reasons to avoid the tool. The goal is to make the amount of trust proportional to the action. A title brainstorm needs little ceremony. A contract summary, financial model, or customer email deserves a deliberate review.

16. Twenty moves that make ChatGPT more useful

1. Name the reader. “For a new hire” changes structure more than “be detailed.”
2. Ask for a decision artifact. A recommendation with evidence beats a long generic summary.
3. Give the real file. A model cannot infer the contents of a document you have not attached or connected.
4. Say which source wins. When notes disagree with a current policy, tell it which is authoritative.
5. Set a stopping rule. “Return the draft and stop before sending” prevents an unwanted action.
6. Request a claims table. It exposes unsupported statements before they enter public copy.
7. Use examples as constraints. Show one paragraph in your voice rather than saying “sound like me.”
8. Ask for assumptions. Missing facts become visible instead of being silently invented.
9. Show a failed example. “This is too salesy” is easier to learn from with the sentence attached.
10. Make success observable. “The totals reconcile” is more useful than “make it accurate.”
11. Separate exploration from execution. Brainstorm broadly, then choose one direction and build it.
12. Use small checkpoints. Review the outline before a 30-page document when the direction is uncertain.
13. Escalate the model deliberately. Save Astra for tasks where harder reasoning changes the outcome.
14. Keep instructions short. Long permanent prompts can crowd out the task in front of you.
15. Verify prices and availability today. Those details decay quickly.
16. Open the artifact. Read the PDF, inspect the spreadsheet, or click the live page.
17. Correct mid-task. A brief course correction is cheaper than a complete redo.
18. Reuse the successful prompt. Save it with the input sources and the QA checklist.
19. Schedule only after one clean manual run. Automation scales both quality and defects.
20. Tell your audience what to do next. A good guide ends in an action they can finish.

Pick three of these for your next task. Trying all twenty at once will create more process than value. The point is to build a personal workflow you can repeat, not a ritual you must memorize.

17. Seven days from beginner to a repeatable system

Day 1 — One good chat. Take a real document or question. Use the six-part prompt. Ask ChatGPT to identify assumptions, then verify the answer. Save the final prompt and one lesson from the result.

Day 2 — Your personal brief. Add a short set of durable preferences. Compare one response before and after. Remove anything that makes the answer stiff or repetitive. Create a Project for a topic you revisit.

Day 3 — Research. Ask a current question that matters to you. Require primary sources, a claims table, and a date. Open the three most important links. Note any claim that is an inference rather than a documented fact.

Day 4 — A finished file. Use Work to turn a source into a memo, spreadsheet, or presentation. Specify audience, format, and acceptance test. Open the file and fix at least one concrete issue.

Day 5 — A connected workflow. If you have a supported plugin, use it for a read-only task with a narrow date range. Check what it actually accessed. If you do not need a connector, use the built-in browser for a bounded comparison instead.

Day 6 — Build or improve a tool. In Codex, make a small change to a website, script, or project. Ask for the relevant files, an implementation, and verification. Inspect the working result. If code is not part of your work, use this day to create a reusable skill or template for a repeated writing task.

Day 7 — Design your first repeat. Look at what worked during the week. Turn the best prompt into a simple procedure: input, output, source of truth, review check, and owner. Run it once more manually. Only then decide whether it should become a scheduled task or a viewer-facing automation.

At the end of the week you should have more than familiarity with features. You should have at least one useful artifact, one prompt you trust, a set of sources you know how to check, and a workflow you can repeat.

18. Quick fixes when the result feels wrong

“It sounds generic.” Give one example of your voice and name the audience. Ask it to replace vague claims with specific actions and examples. Tell it which phrases you would never say.

“It made up facts.” Provide the source of truth, ask for a claim ledger, and require direct links. Remove unsourced claims. For current details, run a fresh search.

“It ignored part of my request.” Turn the requirements into a short checklist and ask it to map each item to the output. If the task is very long, break it into reviewable phases.

“It asked too many questions.” Say which assumptions it may make and which uncertainties truly require your answer. A productive task should proceed through routine choices.

“It created a file, but I cannot use it.” Open the file and give concrete feedback: wrong dimensions, broken formula, crowded slide, inaccessible contrast, missing source. Ask for a revised artifact, not a written promise to revise it.

“The automation runs but the output is noisy.” Tighten the trigger, source scope, and notification rule. Define what counts as a meaningful change and when it should stay quiet. Review the first runs before trusting it unattended.

“Astra is slower than I expected.” Check whether you actually need its depth. Try Sol or the default for a smaller first pass. Give Astra the difficult integration or review step where its extra capability pays off.

19. The AGI Guide starter pack

Here are the five prompts I would keep if I were setting up a fresh account today. Save them in a note or Project. Replace the bracketed text with your own information and test each on a real task.

1. Make a decision.

I need to decide [decision] by [date]. My options are [options].
My priorities, in order, are [priorities]. Use [sources].
Build a comparison table, recommend one option, state the strongest argument against it, and list the one fact that could change your recommendation.

2. Learn a new skill.

Teach me [topic] by helping me complete [small real project].
Assume I know [baseline]. Explain one concept at a time, give me a short action, and check my result before moving on.
When I make a mistake, diagnose the cause instead of just giving the answer.

3. Turn source material into content.

Use this transcript and these source links to draft a [format] for [audience].
Keep my direct voice and include the steps someone can actually follow.
Mark claims that need a fresh verification and show the source for each.
Give me a strong opening, a worked example, and a clear next action.

4. Build a useful file.

Create a [document/spreadsheet/deck] from the attached material for [reader].
The file must help them [decision or action].
Include [sections or sheets], preserve [important source details], and flag missing information.
Open or inspect the finished file and report the checks you performed.

5. Make a repeatable workflow.

I do [task] every [frequency]. The input is [source] and the useful output is [artifact].
Help me turn one manual run into a repeatable process.
First identify the source of truth, failure cases, review checks, and permission boundaries.
Then draft a prompt I can test manually. Do not schedule it yet.

If you only remember one principle from this guide, let it be this: tell ChatGPT what done looks like, give it the material needed to get there, and inspect the result where it will be used. The model matters. The workflow matters more.

20. Plans, limits, and the honest buying decision

Do not buy a subscription because a tutorial told you a model name. Start with your task and your actual usage. A free account is enough to learn prompting, test a research question, and see whether the interface fits your work. A paid plan becomes worthwhile when you repeatedly hit a limit that blocks useful work, need more capable models or tools, or produce enough value from finished deliverables to justify the subscription. Team plans are about shared administration, governance, and data handling as much as model access.

My practical buying test has four questions. First, what task will you finish at least twice a month? Second, which feature or usage limit stops you today? Third, what is that bottleneck costing you in time or money? Fourth, will you actually use the added access during the next 30 days? If you cannot answer those questions, keep experimenting before upgrading.

There is a separate trap for developers: ChatGPT subscription access and OpenAI API usage are billed differently. A subscription does not automatically make API calls free, and the API model's per-token price does not tell you what a ChatGPT plan costs. If you are building an app, estimate API spend from a representative task and check current API pricing. If you are choosing a ChatGPT subscription, check ChatGPT pricing and the limits shown inside your account. Do not mix the two numbers in a budget.

Model limits are also not the same as a monthly data allowance. A plan may have different caps for advanced reasoning, files, image generation, voice, or autonomous work. Some features are still rolling out. If a friend sees a control you do not, inspect your plan, product surface, region, and workspace settings before assuming the tutorial is wrong or your app is broken.

When comparing plans, make a tiny table with four rows: your recurring task, the specific feature it needs, how often you will use it, and the current official plan that includes it. Ignore feature names that you have no intention of using. Revisit the decision after a month. A smaller plan plus a clear workflow often beats a larger plan used without a purpose.

For teams, run a pilot with one process and a small set of users. Choose something observable, such as faster support summaries or cleaner sales research. Define the privacy rule, source-of-truth files, review owner, and metric before rollout. If a pilot cannot show a useful result, broad deployment will not magically fix the instructions.

21. Context: why long chats can drift

A context window is the material the model can consider for a response. It includes your messages, instructions, tool outputs, and attached content that is in scope. Astra's API specification lists a very large context window, but large capacity is not a reason to make every conversation endless. Old drafts, repeated corrections, and contradictory instructions create noise even when they technically fit.

When a chat starts to drift, do a clean handoff. Ask for a short summary of the goal, decisions made, source-of-truth files, current status, unresolved questions, and next action. Start a new conversation or task with that summary plus the actual current files. Do not paste a hundred turns when ten lines and a real artifact will do. The model will have a clearer working set, and you will be able to audit what context it used.

Create a handoff note for a fresh ChatGPT task.
Include: objective, audience, authoritative sources, decisions already made, current artifact and URL, open issues, and the next concrete step.
Exclude old ideas we rejected and any sensitive details not needed for the next step.
Keep it under 300 words.

For repeat work, put durable instructions in a Project or skill and current facts in a dated source. If a product price changes every week, do not bury it in a permanent instruction. If your voice and audience rarely change, they belong in reusable context. Separating stable preferences from changing facts reduces stale answers.

Be specific when attaching multiple files. Tell ChatGPT, “Use 2026-09-final-pricing.csv for numbers, and use brand-voice.md only for tone.” File names alone are not always enough when several similar versions exist. If the output contradicts a source, ask it to locate the exact supporting line. If it cannot, fix the source selection before polishing the wording.

A large context window is most valuable when a genuinely large body of material must be reconciled: a codebase, several research reports, or a long contract bundle. Even then, identify the decision you need. “Read everything” gives the model an unclear job. “Compare these agreements for termination, renewal, and data-use differences, then create a clause-linked table” tells it where to focus.

22. Your on-camera walkthrough

If you are filming a beginner video, structure it around visible wins. Begin with a task your viewer recognizes, then show the first prompt, the result, one mistake, and the correction. Explain Astra only when the job becomes hard enough to show its value. A model picker tour at the start is less memorable than watching a rough document turn into a useful brief.

A strong opening could be: “Most people use ChatGPT like a fancy search box. In the next few minutes, I’m going to give it a real job, show you exactly what to paste, and show you how I check whether the result is actually good.” That is a promise the written resource can support. Do not promise access to a plan or feature that every viewer may not have. Say where the feature appears in your account and offer a fallback task using the default model.

I would film five chapters. In chapter one, make a small result in Chat using the six-part prompt. In chapter two, show the same job upgraded to Work with a finished file. In chapter three, ask for current research and click through the citations. In chapter four, show Astra on a genuinely difficult job: a multi-source comparison, a site change, or a messy document. In chapter five, open the companion resource on a phone and copy a prompt into a new task. This is enough variety to feel comprehensive without becoming a menu tour.

Build a proof board before recording. Put the source files, prompts, expected outputs, official links, and final page URL in one place. Rehearse the slowest live step so you know whether to record a prepared result. If the demo uses a connected account, remove private notifications and use safe data. If a feature is unavailable during filming, explain the path you can demonstrate and let the written guide carry the broader options.

The companion resource should work even if the viewer skips half the video. Put the value high on the page: what they will learn, the first copyable prompt, and the table of contents. Keep the URL stable. A comment-to-DM automation should send the resource in one tap, but the page itself must deliver the promised value. When you change the video title or keyword, update the automation routing rather than changing the resource URL that viewers may have saved.

23. A beginner's FAQ

Do I need GPT-6 Astra to follow this guide? No. Use the best model available in your account. The core workflow—clear outcome, good sources, reviewable result—works with other models. Astra is most helpful for the hard, multi-step examples.

Is Work the same as Chat with a longer prompt? Work is designed to complete tasks using multiple steps and tools and can return files or other deliverables. A clear prompt still matters, but the product is oriented around finishing the assignment rather than only answering it.

Can I give ChatGPT a website URL and assume it read the whole site? Do not assume. Ask it which pages it accessed and check the specific citations. Some pages require sign-in or block access. If the page is essential, paste the relevant material or connect the correct source through a supported tool.

Will it remember everything forever? Do not build a workflow around that assumption. Review memory settings, keep durable files in a Project or connected location, and give current task context when it matters. A saved preference is different from a source document.

Can it send an email or book something for me? Supported connected tools and browser workflows can take actions, but access varies and consequential actions may require review. Start with a draft or read-only step, then inspect the exact destination and content before authorizing the action.

What if the result looks right but I cannot check it? Ask for a source trail, calculation, or small sample you can independently verify. If the task is too important to check, reduce it to a narrower, testable question or involve a qualified reviewer.

Should I use a prompt framework every time? No. Frameworks are training wheels for remembering missing context. Once you can state the outcome, sources, constraints, and test plainly, you already have the useful part.

How do I keep up when features change? Save the official documentation links, note when you last checked a claim, and update the resource when the product changes. A good guide teaches the decision process as well as the current buttons.

When should I automate a workflow? After one clean manual run and a second run that proves it is repeatable. You should know the trigger, data source, output, review check, and failure notification before scheduling it.

What should I do next? Pick one task from your actual week. Copy the starter prompt from Section 19, attach the real material, and set a simple acceptance test. Finish that task before exploring another feature.

Before you start a paid or high-stakes task, make one final decision about review ownership. If ChatGPT is drafting a public claim, a human should verify the source. If it is changing a production site, someone should open the live page. If it is building a financial model, someone should reconcile the totals. The same person can perform all three checks in a solo workflow, but the responsibility should be explicit. “The AI checked itself” is not a reliable control.

When you share this guide with a friend, do not tell them to set up every feature. Ask what they are trying to finish this week. Point them to the closest example above, let them copy one prompt, and help them inspect one output. That is the moment the tool becomes useful. The rest of the guide is a reference they can return to as their tasks get harder.

If you teach a team, keep a small library of examples that actually worked: the original input, the prompt, the final artifact, the review notes, and the time saved. Remove private data before sharing. Update examples when the interface changes. This turns an abstract AI training session into evidence that a specific workflow belongs in your organization.

Sources and update note

This guide was written for The AGI Guide and last checked in September 2026. OpenAI's product access, limits, and pricing can change. Use these primary references when a detail matters: GPT-6 Astra model specification, GPT-6 family guidance, ChatGPT Work, ChatGPT browser, Computer Use, Plugins, Scheduled tasks, and current ChatGPT pricing.

The live companion page is The Complete ChatGPT + GPT-6 Astra Guide. If you are watching the video, keep it open beside you and copy one prompt into your own real task before moving to the next section.