An OpenAI employee explains how to get more from GPT 6 Astra: rethink how people and AI share the work

Give it the right tools so the result stays inspectable and editable

The first version of the Golden Gate Bridge came from Astra working with two tools: it first surveyed what parts BrickLink Studio's built-in library offered, used Python code to assemble the model, then opened Studio to review and refine. The code handled batch generation; the design software let it see whether what it generated actually worked.

The author asks for a Golden Gate Bridge model and specifies Studio. Source: Dominik Kundel.

The first version of the Golden Gate Bridge model, rendered later with studio lighting. Source: Dominik Kundel.

Close-up of the bridge deck: lanes, cars, and brick connection details. Source: Dominik Kundel.

Kundel ended up with a brick model he could open and inspect in Studio, with the close-up of the deck revealing lanes and cars. The full scene used studio lighting configured later; the roughly ten-minute mark refers to that initial version, which still needed polish afterward. Watching the code and software cooperate so naturally even made him reconsider whether doing it by hand would actually be faster.

This gives "handing it to AI" a more concrete meaning. It can produce in one place, check in another, and then assemble the pieces. When choosing tools, start with what you already know how to use: Studio for LEGO, Blender for 3D, DaVinci Resolve or similar dedicated software for video. With the right editing tool available, you don't need to confine all video work to FFmpeg commands.

The 3D room reconstruction makes this workflow clearer still. Kundel gave Astra ten casual photos of his home bar, without measurements. Astra estimated scale from reference objects in the photos, such as a cocktail book, then in Blender—the 3D modeling software—it built each object, inspected it separately, and placed it into the shared scene for further adjustment. It operated both the software's interface and the command line.

A home bar reconstructed from ten photos: counter, seats, wall shelves, lights, bottles, and glasses all sit in the same 3D scene. Source: Dominik Kundel.

The room included furniture, shelving, bottles, and glasses, along with a corner chair and stray cables. Keeping those as individual objects means edits stay local: if the chair looks wrong, change the chair; if the lighting is off, adjust the lighting. Kundel later modified materials and lights, and could also open the scene to view it from different angles.

Even when the final output will live on the web, some 3D work can still start in Blender. For the user, tool choice shapes what you end up with: whether you can open and check it, whether a single object can still be modified, whether it can move into downstream work.

You describe the what; it fills in the operational details

Tools give Astra the means to act; requirements give it direction. Kundel wanted to build Thumbnail Studio, a browser-based image editor for creative assets. He described the idea verbally and pointed the model to his conversations with colleagues.

The input shown in the video was actually substantial: Slack threads, the website codebase, brand guidelines, and core capabilities like uploading background images, rearranging elements, and using templates. He also asked for a clean interface. The phrasing can be loose, but purpose, references, and important requirements still need to come through.

What Astra filled in were the operational specifics that were not spelled out item by item—undo shortcuts, layers, and the ability to hide layers. Those are judgments about how an image editor should behave for a person using it.

Play video showing spoken requirements and the editor's first draft.

22 seconds: from spoken requirements to the first Thumbnail Studio draft. Source: Dominik Kundel.

Thumbnail Studio after further iteration: editing tools and layers on the left, canvas in the middle, thumbnail preview and feedback on the right. Source: Dominik Kundel.

For people who want custom software for their own work, this division is useful: first state the problem you are trying to solve and roughly what you want the software to feel like, then try the working version and decide what to keep and what to change. You do not need to spec out every button's behavior before you start.

The LEGO model showcase site illustrates a further level of product thinking. Kundel asked that visitors be able to view models in 3D and download building files; Astra also added an upload interface for new models. As he described it, this admin entry point uses Sign in with ChatGPT to restrict access to him alone.

That upload-and-admin layer addresses how the site will keep growing and who maintains it. The model was reasoning not only about what a visitor sees on a single page but also about how the author will use this software going forward.

Still, specific aesthetic choices need human direction. To land on the space theme he envisioned, Kundel provided further references and asked explicitly for interactive, rotating planets. Once a feature or visual direction is decided, say so directly; what you hand off is the detail work you are comfortable letting it judge.

Once you have a first version, iterate against concrete results

A first version turns an idea into something you can point at and critique. The next round of feedback can target a single button, a region of the screen, or a moment in an animation—you no longer have to imagine the final effect from words alone.

Kundel later asked for a "product feedback mode" with automation to periodically review, triage, and implement incoming feedback. Astra built out the interface for this direction: select a spot in the app, pin a comment there, set a priority, edit the feedback, and mark issues resolved.

That way, issues discovered while using the software stay anchored where they occur. The next round has clear targets: what to change, what to do first, what is already done. The original demo showed those interface actions; the periodic processing was the automation the author requested.

The animation case shows how references and feedback work together. Kundel admires Nick Baumann's animation style, so he gave Astra access to Appshot screenshots with context, the article he was writing, and the Codex app's codebase.

The original request was also very specific: it asked for two animation concepts first so he could respond, one of which had to explain the difference between an AI clicking through a UI versus directly invoking a dedicated tool. The author had already specified what the animation needed to communicate.

The animation request includes a reference image and explains the 3D operation scene it should depict. Source: Dominik Kundel.

Astra read the 3D demo in the article, rebuilt the interface so it could be animated, and added composition, camera angles, and captions. It also built an extra preview tool that let Kundel play, pause, loop, and inspect from different angles, then mark up issues using the built-in browser annotation tool.

Comparing the video shows concrete changes: the first version presented a single modeling window alongside a conversation; the published version placed two modeling windows side by side, each with its own explanation area below. With both interaction styles in one frame, the difference is easier to see. The value of that preview tool was being able to look at the actual output and make further demands from there.

Even gathering the material for this comparison video was folded into the task. Kundel asked Astra to retrieve the earlier animation from an old conversation, find the screen recording on the desktop, and pull the final version from the X article; it located the pieces and assembled the video. He could say what outcome he wanted and let the model handle finding and combining within the locations given, avoiding the normal prep of locating each file himself.

Start with a simple setup and tune guidance and reasoning level against the output

Looking at results like these, another habit is worth revisiting: how much of the guidance we used to add for older models does a new model actually still need?

When the team had Astra cut a release video, some Skills written for earlier models actually got in the way; a simpler setup without the video-editing Skill performed better on that task. If a Skill mostly patched an older model's weaknesses, compare results with and without it on the same task before keeping it.

The same experimental approach applies to reasoning levels. Levels like Low, Medium, and Max indicate different reasoning intensities. In some of his Blender tests, Kundel preferred Astra's output at Low over another model's—GPT-5.6 Sol at Max. He also noticed Astra checking its own work carefully even at lower levels.

In the video, Sol is on the top row and Astra on the bottom, each ordered left to right by reasoning level, rotating through three subjects: character, architecture, and room. You can compare shape, composition, and detail on the same subject to see which result lands closer to what you want.

When trying this yourself, start at Low or Medium, do a round, then adjust upward or downward. Kundel also offers Model Observatory as an entry point for more comparisons. Neither old Skills nor the highest reasoning level need to carry over automatically; whether more guidance or reasoning is needed should be judged against the specific task and its output.

Let it check the actual result and agree on when to hand back

Once you let the model run, the final question is: how do you know it is done, and at what point should it hand control back?

Kundel observed that Astra, when building a game, might start playtesting; when optimizing, might set up an environment to measure effects; when processing video, might inspect individual frames or audio waveforms. The checks land on the artifact's real performance.

The cover demo offers a more specific example. Astra noticed that in its previous round it had fixed the cropping but left the preview aspect ratio too tall. A search pointed to 5:2, but the X help page gave no dimensions, so it went on to check the actual article page's code, confirming the ratio at the time was 5:2 at 1200 × 480 pixels, then explained the adjustment to ratio and centering so the subject stayed fully visible.

That check chased two things: whether the original crop problem was solved and whether its own change had just introduced an aspect ratio problem. The actual page where the final asset would appear gave it grounds to correct itself.

Checking also needs an endpoint. If you only want a prototype you can play with yourself, say the goal is a playable version; if you want the model to play through completely and fix issues, write that into this round. You can also agree: check one pass against what you care about, report what was found and what remains unresolved, then hand it back.

Applying these lessons to your own tasks, the brief can cover the following:

Kundel's final suggestion is to pull out a task you once abandoned. Give Astra the right tools, references, and completion criteria, start at a Low or Medium reasoning level, see how far it gets, then add guidance. The attempt is both a test of the model and a fresh judgment call: which preparation, production, and checking work is already worth handing over.