01 · Reality check
What ChatGPT actually does well here
Good at
- Turning an outcome into a sequence of inspectable steps
- Working through long documents, codebases and structured artifacts
- Using tools when the task, permission and stopping rule are explicit
- Following a project style when durable instructions are available
- Delegating bounded research or implementation subtasks
- Explaining assumptions, uncertainty and verification status
Not the right tool for
- Knowing what you meant when the success condition is vague
- Deciding whether an external action is authorised just because it is useful
- Replacing primary sources for current product, legal or pricing claims
- Guaranteeing that generated code, numbers or citations are correct
- Choosing your risk tolerance or silently changing the brief
- Being a substitute for review of irreversible or high-impact actions
02 · The method
Step by step
- 1
Name the finished outcome
Start with the artifact or decision you want, not a role. Say what should exist at the end: a tested pull request, a two-page brief, a reconciled workbook, or a source-backed answer. If there are several outputs, rank them. A role such as 'expert assistant' is not a definition of done.
- 2
Separate goal from method
Tell Astra what must be true and let it propose a method when the method is flexible. If you already require a method, say so explicitly. For example, 'use the existing parser and preserve the route' is different from 'find any way to publish this'. This prevents a capable model from optimising the wrong thing.
- 3
State authority and non-authority
Write down what Astra may read, edit, run, send or publish, and what it must leave alone. Include boundaries such as 'do not change dependencies', 'do not contact anyone', 'do not deploy', or 'ask before deleting'. Permission is part of the prompt, not an assumption that follows from the goal.
- 4
Give it a source hierarchy
For current facts, specify which sources win. A useful order is official product documentation, the vendor's current pricing or help page, an authoritative regulator, and then secondary explanation. Tell Astra to cite the source and date, mark unresolved claims, and never turn a research lead into a fact.
- 5
Use instruction priority deliberately
Put durable project rules in the repository's AGENTS.md or equivalent project instructions, and put task-specific decisions in the request. Explain which instruction controls a conflict. Do not paste secrets or private tokens into an instruction file. A short, maintained rule set is easier to audit than a giant prompt that repeats itself.
- 6
Ask for a plan before irreversible work
For a consequential task, request a short plan containing files or systems in scope, assumptions, risks, checks and the first safe step. Do not require a ceremonial plan for every tiny edit. The point is to expose a mistaken interpretation before it turns into a broad change.
- 7
Define initiative as a bounded loop
Astra can often continue through obvious substeps when you say what 'continue' means. Try: inspect the repository, implement the smallest complete change, run the named checks, fix failures caused by the change, and stop when the acceptance criteria pass. Add 'do not expand scope to unrelated warnings' when the workspace is noisy.
- 8
Give long tasks a progress contract
Ask for updates only at meaningful milestones: discovery complete, implementation complete, checks running, blocked or ready. Each update should say what changed, what remains and whether a decision is needed. This is more useful than asking for constant narration, and it keeps attention on the deliverable.
- 9
Use examples for style, not hidden requirements
Provide one or two representative examples of the voice, data shape or output format you want. Label examples as examples. If a rule is mandatory, state it as a rule. Otherwise Astra may imitate an incidental detail while missing the requirement that mattered.
- 10
Prompt for writing that sounds like you
Describe the reader, purpose, point of view, sentence density, banned habits and evidence standard. Ask for a brief outline and a claim-to-source map before a long draft. A style prompt should control choices such as headings, directness and examples; it should not ask the model to pretend it had experiences or tests it did not have.
- 11
Delegate by handoff, not by hope
A good subtask has one owner, one input bundle, one output schema and one stop condition. Ask a delegated researcher for a source table, not a vague 'look into this'. Ask a coding subtask for a patch and tests, not 'improve the project'. Review the handoff before composing it into the final result.
- 12
Ask for tests that can fail
A verification request should name a failure signal. For code, that might be a unit test, type check, link check or reproducible command. For research, it might be a source URL, publication date and a second-source contradiction check. 'Make sure it works' is encouragement, not a test.
- 13
Use a decision log for changing assumptions
When a task evolves, ask Astra to record the decision, the evidence, the alternatives rejected and the impact on scope. This is especially useful for migrations, data cleanup and product research. A short log prevents a later reader from mistaking an assumption for an original requirement.
- 14
Make stopping a success state
Tell Astra when to stop and report a blocker: missing access, conflicting requirements, unavailable source, failed safety check or an action requiring approval. Do not encourage it to work around an authority boundary. A clean blocked report is better than a plausible artifact built on an invented premise.
- 15
Review the result at the right layer
Check the artifact itself, not only Astra's summary. Open the changed page, inspect the diff, recalculate important numbers, click links and read the cited source. For a long task, ask for a final manifest of files changed, commands run, checks passed, assumptions left and actions not taken.
- 16
Iterate with deltas
When the first result is close, describe the exact delta: keep the structure, replace the unsupported claim, shorten the second section, add a missing test, or preserve the original date. Avoid restarting with a totally new persona prompt; it can discard useful context and make the acceptance criteria less stable.
03 · Use this now
Copy-paste prompt for a bounded GPT-6 Astra task
Copy and paste
You are helping me complete a defined task. Work as an initiative-taking assistant inside the boundaries below. OUTCOME Create: [the exact artifact or decision] Audience: [who will use it] Definition of done: [observable checks that must pass] SCOPE AND AUTHORITY You may read: [files, URLs, data] You may change: [exact files or systems] You may run: [commands or tools] You may not: [deploy, send, delete, publish, change dependencies, access secrets, or other exclusions] Ask before: [irreversible or external actions] SOURCES AND EVIDENCE Use these sources first: [official docs, supplied files, primary sources] For every current or consequential claim, give the source URL and date. Separate verified facts, my supplied assumptions, your inferences and unknowns. Never invent a test, result, citation, price, person or access condition. WORKING METHOD 1. Inspect the in-scope material and list the smallest complete plan. 2. State assumptions and any blocker before acting on them. 3. Implement the smallest complete change that meets the outcome. 4. Run: [named checks]. Fix failures caused by your change, but do not widen scope for unrelated failures. 5. Stop when the definition of done passes or report the exact blocker. PROGRESS FORMAT Update only at these milestones: discovery, implementation, checks, ready or blocked. Each update must name what changed, what remains and whether you need a decision. FINAL REPORT Summarize the artifact, files changed, checks and results, sources used, assumptions left, actions not taken and any follow-up I should review.
04 · Avoid these
Common mistakes
- Writing a broad objective and assuming initiative will infer the boundary
- Using a role label instead of an observable definition of done
- Treating a supplied title or claim as verified research
- Putting project rules only in a one-off prompt when they should persist
- Asking for constant progress narration instead of milestone updates
- Delegating a vague subtask with no output schema or stop condition
- Calling a generated answer tested when no test was actually run
- Letting a model decide that an external or irreversible action is authorised
- Accepting a polished summary without opening the artifact or source
- Restarting the whole prompt when a small, explicit delta would be clearer
05 · Questions
Frequently asked questions
What is different about prompting GPT-6 Astra?
The important shift is operational rather than magical. Astra is intended for demanding, multi-step work with tools, files and longer follow-through, so a useful prompt behaves like a work brief: outcome, scope, authority, evidence, checks and stop conditions. You still need ordinary clarity, and a more capable model does not remove the need to review its work.
Should I give GPT-6 Astra a role?
A role can set useful perspective, but it should come after the outcome and boundaries. 'Act as a careful release engineer' helps only when paired with the repository, files, permitted actions and acceptance checks. A role cannot supply missing facts or permission. If the role conflicts with a concrete requirement, the concrete requirement should win.
How do I get Astra to take initiative?
Define initiative as a permitted loop: inspect the in-scope material, make a plan, complete necessary substeps, run named checks, fix failures caused by the change and stop at the definition of done. Also state what it must not do. This gives Astra room to follow through without turning every useful idea into an authorised expansion.
How do I stop GPT-6 Astra from changing too much?
Name the exact scope and exclusions. Say which directories, records or systems may change, which commands are allowed, whether new dependencies are forbidden, and what requires approval. Ask for a final changed-file manifest and review the diff. If the task is risky, require a plan before edits and a checkpoint before any external action.
Should I use AGENTS.md with GPT-6 Astra?
Use a maintained project instruction file for durable repository rules such as commands, architecture boundaries, style, testing expectations and files that require special care. Keep it concise and specific. Put the current task's goal and temporary decisions in the prompt. Review instruction files like code: remove stale rules, avoid secrets and explain precedence when multiple files apply.
What should a good GPT-6 Astra coding prompt contain?
Give the desired behavior, relevant entry points, constraints, allowed files, commands to run, definition of done and edge cases. Ask Astra to inspect before editing, preserve unrelated work and report the diff. Include a test command that can fail. If the repository has existing changes, say they are out of scope unless the task explicitly includes them.
Can GPT-6 Astra browse and research for me?
It can help with research when the product and tool access support it, but the prompt should define a source hierarchy and require links and dates. Ask it to separate primary evidence from interpretation and to flag claims it could not verify. Browsing capability is not a license to treat a search snippet, old page or model memory as current fact.
How should I prompt Astra for current pricing?
Ask it to use the vendor's current pricing page or official rate card, record the access date and currency, and distinguish list price from credits, taxes, regional pricing or contract terms. Tell it not to fill missing numbers from memory. Pricing changes, so the article or decision should preserve the source link and a refresh date.
Can Astra write in my style?
Give it a short style brief and a small representative sample, then describe the reader and purpose. Point out habits to avoid, such as inflated claims or generic filler. Ask it to preserve your facts and mark any missing evidence. Do not ask it to manufacture first-person experience, tests or opinions you did not provide.
What is the best way to use subagents?
Use subagents for separable work with a bounded input and a structured handoff. Examples include checking links, extracting claims from a supplied document or writing tests for a specified behavior. Keep integration and final judgment with one owner. A larger number of agents does not automatically improve quality; it can multiply contradictory assumptions.
How do I ask Astra to keep me updated?
Specify milestone updates rather than a stream of narration. For example: report after discovery, after the implementation is complete, when checks start, if blocked, and when ready. Each update should say what changed, what remains and whether you need to decide something. This keeps long work legible without making progress itself the deliverable.
Should I ask GPT-6 Astra to explain its reasoning?
Ask for concise, inspectable evidence: assumptions, decision criteria, source mapping, changed files, test output and unresolved risks. That is more useful than requesting hidden internal reasoning. You need an auditable explanation of the work and its limits, not a theatrical transcript of every internal thought.
How do I use Astra for spreadsheets?
Describe the columns, date range, expected totals, formula compatibility and privacy limits. Use a redacted or synthetic sample, preserve the source and ask for formulas plus a reconciliation check. Inspect formulas in the workbook and compare control totals. A generated spreadsheet is an artifact to review, not proof that every cell or feature is correct.
Can Astra make decisions for my team?
It can structure options, summarize evidence and apply criteria you define. Keep the accountable decision with the person or group authorised to make it, especially for hiring, finance, legal, medical, security or access decisions. Ask Astra to show trade-offs, missing evidence and the consequence of each option rather than presenting a single answer as inevitable.
How should I prompt for a long document?
Start with the reader, decision, source set and structure. Ask for a claim map or outline first, then draft in sections while preserving terminology and citations. Include a final audit for unsupported claims, repetition, contradictions, accessibility and links. A longer context window helps, but it does not make a document automatically accurate or well edited.
What if GPT-6 Astra says it completed something I cannot find?
Ask for the exact path, URL, command, timestamp or returned identifier, then verify it yourself. A summary is not evidence that an artifact exists. If an external action was supposed to happen, check the destination system and its audit trail. Treat an unverified completion claim as incomplete until the result is visible and correct.
Does GPT-6 Astra replace testing?
No. It can help design and run tests, interpret failures and suggest edge cases, but tests still need to execute against the real artifact and meaningful inputs. Ask for checks that can fail and report their output. For research or writing, use source and link audits instead of claiming a software-style test proves truth.
How do I handle a blocker without letting Astra guess?
Tell it to stop and report the missing authority, source, access or decision. Ask for the smallest safe alternative, if one exists, and clearly label it as an alternative. Do not reward a plausible guess when the missing fact controls the outcome. A precise blocker is useful information that lets you make the next decision.
What should I review before accepting an Astra result?
Review the artifact, the scope, the evidence and the checks. Open changed files, click important links, recalculate important numbers, inspect permissions, read the source and compare the result with the definition of done. For external actions, confirm the destination and reversibility. Ask for assumptions and actions not taken so the gaps are visible.
Where can I verify GPT-6 Astra availability and pricing?
Use OpenAI's current product announcement and Help Center pages for model identity and ChatGPT or Work availability, and the official API model or pricing documentation for API access. Plan names, limits and regional availability can change. Record the page and date in any published guide rather than relying on a remembered number.
Related guides
Primary sources
- OpenAI: GPT-6 Astra announcement
- OpenAI Help: GPT-5.6 and GPT-6 Pro in ChatGPT
- OpenAI Help: ChatGPT Work and Codex
- OpenAI API documentation
Product menus and plan limits change. The linked vendor documentation is the authority when your screen differs.