We can't find the internet
Attempting to reconnect
Something went wrong!
Hang in there while we get back on track
🔥 TOP SIGNAL
The high-alpha shift is from code generation to closed-loop computer operation. Riley Brown reports that GPT-6 Astra in Codex took an estate PDF containing a floor plan, created a Blender scene in about 20 minutes, then generated a playable map in an existing Call of Duty-style game after about an hour. In the same workflow, the agent inspected screenshots, launched and played the game, caught an incorrect texture, reprompted itself, and retested; AMP describes the production analogue—phase a migration, inspect logs and database invariants, advance only when healthy, and roll back otherwise.
⚡ TRY THIS
Build around an acceptance loop, not a patch. Use this prompt shape:
Build [artifact] from [input]. At each stage, render or launch it, exercise [real flows], inspect the result, and fix/retest until [acceptance criteria].Brown’s demo is the pattern: the agent evaluated screenshots, tested the running game, noticed a texture failure, and iterated. The harness is powerful because it can control the computer, browser, local apps, and files—but Brown’s setup also gives it signed-in applications and API keys. Reproduce this in a disposable environment or with narrowly scoped credentials.Phase-gate production changes. Split a risky migration into backwards-compatible stages; after each deployment, have the agent monitor logs, database state, and explicit invariants; advance only on clean results and roll back on failure. AMP’s proposed permission model is a short-lived OIDC token—30 minutes of read-only access to only the relevant logs or production database—not a developer laptop’s ambient credentials.
Route review by blast radius. Addy Osmani’s default is a multi-agent first pass on every PR to find and verify bugs, rank severity, and suggest fixes. Let low-blast-radius changes in less-sensitive code skip deep human review only after that pass is clean; require an owner and human sign-off for core or sensitive paths. That is a safer default than copying AMP’s no-mandatory-review model, which Quinn Slack explicitly frames as a trusted-team approach for fast-moving end-user software, not all software.
Keep a deterministic test gate while trust is earned. Let the agent test in a reproducible sandbox, but run the full relevant suite in a deterministic CI stage: the agent may not realize that a large change affects code outside its context. Feed failures back to the agent and let it fix and rerun.
📡 WHAT SHIPPED
GPT-6 Astra is now a hands-on Codex model, not just a chat endpoint. Brown says OpenAI released Astra; after about a week of pre-release access and roughly $1,500 in credits, he reports building a game in four prompts, adding multiplayer in the fifth, and streaming it with 20 people. Treat this as a high-signal practitioner report, not a benchmark. The counter-signal is reliability: Theo says Astra has produced both “incredible” and “stupid” results, while Fable 5.1 generally does what he asks.
AMP’s orbs make remote parallelism the default path. AMP describes remote agent workspaces that let developers close their laptops and run roughly 100 things in parallel; Quinn says the workflow changed how the team and customers build software over the preceding few weeks.
Codex is acquiring device-level surfaces. Tibo says the desktop app adds computer use, sub-agent management, voice, and non-blocking context-gathering questions compared with the CLI. A separate hands-on report says Codex can control an iPhone via
npx @swmansion/argent init; treat that as a community-tested integration, not a formal release note.The Frontier AEO tracker turns agent choice into a repeatable comparison. Latent Space runs six prompt variations over seven models across 161 categories, including coding agents, and exposes cited sources and failure analysis. Its coding-agent recommendations are model-conditioned—Fable/Opus favor Claude Code, Sol/Astra favor Codex, and Grok favors Cursor—and its model-comparison pages report consequential choice flips between generations.
datasette-mcp 0.2changes SQL results to model-friendly objects.execute_sqlnow returns an array of objects rather than positional arrays, reducing column-mapping errors for weaker models; the release depends onmcp>=2.1.1and is the plugin’s first non-alpha release.
🎬 GO DEEPER
- Inside the Team That Killed Mandatory Code Review — Quinn Slack, AMP — ⏱️ 3–5 min excerpt. Watch the concrete control loop for a core data-model migration: deploy a phase, inspect invariants, proceed or roll back, and keep production access read-only and short-lived.
- GPT-6 Astra Feels Like AGI — Riley Brown — ⏱️ 4–5 min excerpt. The useful part is not the spectacle; it is the self-testing loop across Blender and a game: screenshot, evaluate, play, find the defect, reprompt, and retest.
- Study Latent Space’s Frontier AEO tracker. Use its prompt/model variation and failure-analysis approach when choosing a coding agent; the point is to test tool recommendations under paraphrase and across model families rather than trust one model’s preference.
Editorial take: The practical moat is now the control plane—a computer-use harness, an acceptance loop that catches mistakes, and permissions and review gates that scale with blast radius—not raw model generation alone.
Direct answer: use the five line-addressable candidates below. The supplied transcripts contain no clock timecodes, so reliable approximate timestamps cannot be recovered; use the cited line ranges as edit boundaries and verify the final 2–5 minute duration in the video.
1. AMP — phased deployment, rollback, and least-privilege production access
Priority: highest AMP cut. Target: 3–5 minutes. Transcript block: L55–L60. AMP describes a migration from one workspace to multiple that requires backwards-compatible phases; after each deployment, the agent monitors logs, the database, and invariants, advances when healthy, and rolls back when not. The proposed access model is an orb agent receiving an OIDC token for 30 minutes of read-only access limited to G-Cloud logs or the production database.
2. Riley Brown — PDF → Blender → playable game map
Priority: highest Riley demo cut. Target: 3–5 minutes. Transcript block: L4–L10. Riley starts with a PDF containing an estate, house, and floor plan, passes it to Codex/GPT-6 Astra to control Blender, gets a house generated in about 20 minutes, then asks the agent to turn it into a new playable “Estate” map in an existing Call of Duty-style game; after about an hour, it returns both the Blender scene and playable map. The demo then shows the generated house in-game, including a helicopter that can be flown and used in combat.
3. Riley Brown — concrete self-testing loop
Priority: highest practitioner-workflow cut. Target: 4–5 minutes. Transcript block: L42–L49. Riley explains the loop as: perform the task, evaluate the result, make changes, and re-evaluate repeatedly. For the estate project, the agent screenshots and evaluates Blender, checks that the game builds, starts a match, moves around the map, boards and flies the helicopter, and checks the house; after noticing an incorrect white texture, it reprompts itself and iterates. Riley’s qualification is that a hard paywall can still stop the process; otherwise, he presents the agent as testing repeatedly until the requested end state is reached.
4. AMP — CI as a deterministic agent feedback loop
Priority: strong AMP workflow cut. Target: 2–3 minutes. Transcript block: L81–L84. AMP’s agent runs tests in a sandboxed, reproducible environment, but CI remains useful as a deterministic stage that runs the full test set, passes failures back to the agent, and lets the agent fix and retry. For editorial balance, the surrounding discussion says part of the AMP team questions whether CI is still necessary, while retaining the value of a reproducible environment for running the project.
5. AMP — remote orbs and parallel cloud development
Priority: useful context cut. Target: 3–5 minutes. Transcript block: L11–L20. AMP describes orbs as remote workspaces that let developers shut their laptops and run roughly 100 tasks in parallel, changing how the team and customers work. The concrete workflow is an agent running in the cloud with a dev server exposed in a portal, desktop access, and parallel execution; the speaker says that once the cloud setup works, developers may stop using local development.
Expert-directed agent build (firsthand, Graham Dumpleton): Wrapture extends
wrapt-style monkeypatching into testing and tracing, can override or observe arbitrary functions, supports OpenTelemetry, and offers configuration-only tracing. Dumpleton says every line of code and documentation was written by an AI assistant under his direction, with the design supplied by his own domain expertise rather than a one-shot “vibe coding” prompt. A reproducible tracing setup is:capture = "summary" [[observe]] target = "domain:Calculator" name = ["outer", "inner"] [[sink]] type = "jsonlines" path = "trace.jsonl"Its test API supports both stubbing
Gateway.charge()and transforming the original method’s return value while still executing it.Separate builder and reviewer models: Simon Willison’s
claude-system-promptsrepository stores model-family prompts with synthesized, date-aligned Git histories so changes can be diffed directly. He had Claude Fable 5.1 build the system and automation, but routed prompt-diff summaries to GPT-5.6 Luna because he did not trust Claude to summarize its own system prompt; a GitHub Actions workflow runs daily or manually.Iterative local artifact workflow: In ChatGPT Codex on macOS, Willison installed the full Blender application and started with
Use the already install /Applications/Blender to render a scene of a pelican riding a bicycle, then iterated withOK add a background and a lot of flairandOK make it a whole lot better. Codex generated the scene through Blender’s Python API, with the resulting script published in thegpt-6-astra-blender-pelican-bicyclerepository; the subscription covered the run, while AgentsView estimated an API-equivalent cost of $4.24.Model/context evaluation signal, with a major harness caveat (secondhand): Willison had not yet tried GPT-6 Astra himself; OpenAI priced it at $10/million input and $50/million output and reported a 99.9% ARC-AGI 3 score. That 99.9% result required OpenAI’s custom Provider Adapter harness and $19,000, while the default harness scored 62.7% at $26,000; the adapter preserves opaque reasoning state between requests and compacts long conversations. OpenAI also reported 100% on its eight-needle benchmark at 256K–512K tokens and 96.3% at 512K–1M tokens. Artificial Analysis found Claude Fable 5.1 ahead on its overall Intelligence Index, but Astra ahead on the Coding Agent Index cost-efficiency frontier and less than half the per-task cost of Fable 5 at the same score.
Agent-facing tool updates:
datasette-mcp 0.2changedexecute_sqlresults from arrays of arrays to arrays of objects so weaker models do not have to track positional column mappings; it is the project’s first non-alpha release and now depends onmcp>=2.1.1.llm-gemini 0.34added Gemini 3.8 Flash with low, medium, and high thinking levels. Willison used it with his basicllm-coding-agentplugin to add sandboxed-iframe rendering for HTML blocks to his Markdown/SVG renderer; a separate “make me a cool thing in html” run took 13 seconds and cost 1.8 cents.Review-risk counter-signal (firsthand Rick Brewster): The Paint.NET author reports that Claude produced a 180,000-line, clean-room Direct2D rewrite for WINE, but says most of it was not thoroughly reviewed; he had to supervise COM reference-counting fixes such as missing
AddRef()calls and reject poor architecture decisions.
- Effect v4 beta and setup: Effect v4 was presented as a beta release that consolidates previously separate packages into the core
effectpackage and includes 17 unstable modules spanning HTTP, AI, schemas, RPC, CLI, workflows, and clustering. The walkthrough used TypeScript 7 withstrict: trueand installedeffect@rc. - Learn before delegating to an agent: The host recommends reading documentation to avoid missing small concepts, rejected starting from an AI-generated Effect setup he could not explain, and warned that visible progress without understanding is a “false illusion of progress.” TJ’s suggested learning progression was to have an agent build a minimal Bun HTTP server with a health endpoint, then extend it into a CLI-backed to-do app using local SQLite/Drizzle, and only afterward add a frontend.
- Constrain agent-written TypeScript with typed boundaries: Guest TJ’s Effect pattern is to encode specific error types and service requirements in the program type, provide required services or composed layers at the boundary, and let missing requirements fail type-checking instead of relying on a global dependency grab bag. This also supports testing: a production user service can depend on Postgres while a test implementation simply returns fixtures or a not-found error; TJ says inspecting the type lets him verify that an AI-generated block cannot open a Postgres connection where it has not been granted one.
- Validate data and external calls: TJ’s codebase rule is that agents must define schemas rather than interfaces and parse data instead of trusting TypeScript assertions; for an unknown HTTP endpoint, an API specification can generate a fetch client that serializes and deserializes through those schemas.
- Use structured concurrency for parallel LLM work: The Effect example migrates
askto Effect’s AIlanguage model generate textAPI and runs text-generation requests in parallel; if one fails, structured concurrency immediately interrupts the others, avoiding the manualAbortControllercancellation wiring required by promise-based code. - Anecdotal model signal: In a firsthand desktop-operation test, the host reported that “GPT56 Luna none fast” was over 50% successful at signing into a computer, reaching the lock-screen flow, and signing back out; the transcript gives no broader benchmark context.
- GPT-6 Astra + Codex (firsthand): Riley Brown reports roughly one week of access to OpenAI’s newly released GPT-6 Astra and about $1,500 in usage; he says he built a Call of Duty-style game in four prompts and added multiplayer in the fifth.
- Replicable multimodal agent loop: Feed Codex a PDF containing an estate’s photos and floor plan, ask GPT-6 Astra to drive Blender to build the 3D scene, then instruct it to turn the result into a playable game map; Brown reports roughly 20 minutes for the Blender scene and about an hour for the scene-plus-map workflow. The reusable pattern is to specify the end state and let the agent inspect, test, and reprompt itself: it took screenshots, evaluated the Blender output, launched and played the game, tested the helicopter and map, noticed an incorrect texture, and iterated.
- Prompt-to-utility workflow: Brown asked Codex for a shortcut-opened, Raycast-style desktop app that searches Google Images, removes backgrounds, and saves copied assets; he reports a working app in 16 minutes. Semicolon-separated terms trigger multiple searches, Command-Enter uses AI to generate searches from a list of entities, and copied assets remain available for reuse.
- Harness comparison and access model: Although Brown says GPT-6 Astra can also run in Cursor, he found it substantially more capable in Codex, attributing the difference to integrated computer/browser use, local app control, file editing, and website testing; he also describes controlling the desktop remotely from a phone. The workflow depends on full access to the host computer, including signed-in browser sessions, GitHub/deployment accounts, and API keys, making permissions and security a core constraint when reproducing it.
- Prototype deployment and always-on orchestration: For a game lead magnet, Brown used the hosted Sites workflow to create a signup page, collect contact information, and add an admin dashboard restricted to his email. He plans to run Codex and other agents continuously on Mac Minis/Linux and control them remotely from a phone or iPad; this is a proposed setup rather than a completed result.
- Firsthand model/tool report —
GPT6 Astrain Codex. Riley Brown says he had access for about a week before release and spent roughly $1,500 in credits; he reports building a Call of Duty game in four prompts, adding multiplayer in prompt five, and streaming it with 20 people. - PDF → 3D asset → playable map. Feed an estate PDF to
GPT6 Astrainside Codex, ask it to control Blender and recreate the property, then have it verify the scene and build a new map in the existing game’s format; Riley says the Blender output took about 20 minutes and the playable map arrived after about an hour. The demonstrated reusable loop is: inspect screenshots/renders, build and launch the artifact, interact with it, evaluate the result, reprompt, and retest; the agent reportedly noticed an incorrect house appearance and iterated on it. - One-prompt local utility pattern. Riley asked Codex for a Raycast-style desktop app launched by shortcut that searches Google Images, removes backgrounds, and saves copied assets; he says it produced the app in 16 minutes. The interaction design uses Command-Shift-Space to open it, semicolon-separated terms for multiple searches, and Command-Enter to have AI turn a multi-person input into separate searches; copied or saved results remain searchable later.
- Harness advantage and access caveat. Riley reports that
GPT6 Astrafeels more capable inside Codex than in Cursor because the Codex harness provides computer and browser use, screenshots, Blender access, website testing, and file editing/deletion. This setup depends on full computer access and logged-in applications: he says the agent can use his browser sessions, GitHub/Vercel, and system API keys. - Hosted app/lead-magnet workflow. Riley reports a
sitescapability with hosting, database storage, and authentication; his example asks for a site styled after his game, collects visitor information, and exposes an admin dashboard only to his email before sharing the site for feedback. - Remote-agent architecture (planned). Riley says he bought two Mac Minis and intends to keep Codex and other agents running 24/7 on a Mac Mini/Linux setup, controlling them from a phone, iPad, or MacBook; he presents this as a setup he planned to implement that week rather than a completed workflow.
- Secondhand model comparison. Riley cites another person’s Microsoft Paint test comparing
GPT6 Astrawith Fable 5.1 and interprets the visual result as substantially favoring Astra for computer use; he also says OpenAI appears to be pulling ahead of Anthropic on that dimension.
- Firsthand context: Quinn describes AMP’s 20-person distributed team as an early, serious user of its own coding-agent workflow.
- Remote parallel-agent workflow: AMP’s “orbs” run the agent remotely, letting developers close their laptops and run roughly 100 tasks in parallel; Quinn says this changed how the team works. An orb starts a sandbox and exposes the dev server through a portal, with parallel jobs designed not to conflict and to receive the required access automatically.
- Deployments as an agentic control loop: For a risky multi-workspace data-model migration, AMP broke the rollout into phases. After each phase, the agent monitored logs and database invariants, proceeded only when results were clean, and rolled back when they were not; Quinn used this process during a 12-hour flight.
- Least-privilege production access: Quinn’s proposed security pattern is to give a cloud-running agent intentionally limited access, obtaining an OIDC token valid for 30 minutes with read-only permissions scoped to selected cloud logs or the production database. He argues this can be safer than a local agent inheriting broad credentials from a developer’s laptop.
- Testing and CI loop: AMP runs the agent’s tests in a reproducible sandbox environment shared by the team. Quinn still sees value in a deterministic CI stage that runs the full relevant test set, passes failures back to the agent, and lets it fix and rerun them because an agent may not realize which tests a large change affects. His contrarian view is that traditional CI may eventually shrink or disappear if agents can reliably run everything and automatically eliminate flaky tests, while reproducible execution environments remain essential.
- Sandbox choice: AMP currently uses E2B. Quinn praises its sandbox primitives and contrasts it with alternatives that lack capabilities such as resuming environments or network access.
- High-trust shipping model: AMP has eliminated mandatory code review before merging. Quinn attributes that to a small team with high ownership and accountability, and favors shipping a fix within about 15 minutes of receiving logs or customer feedback; he explicitly limits this approach to fast-moving end-user software rather than all software.
- Emerging “mini-app” pattern: AMP runs ad hoc internal applications in orbs and lets an agent modify them immediately; Quinn argues that direct agent customization can replace much of the settings-screen and integration overhead of conventional software. He suggests making these apps forkable while keeping front-end/back-end contracts, security, and privacy constraints stable.
Latent Space Frontier AEO tracker: Latent Space built the Frontier AEO tracker after a few billion tokens of prototyping, alignment, and scaling; its methodology runs six prompt variations over seven models with search enabled across 161 categories, including coding agents. Astra performs answer extraction using a score that weights first choices, alternatives, mentions, and negative anti-recommendations; the project also exposes prompt/answer pairs, cited sources, and failure analysis.
Model-conditioned tool-selection bias: When asked for coding-agent recommendations, Fable/Opus favored Claude Code, Sol/Astra favored Codex, Grok favored Cursor, Muse favored Muse Code, and SWE-1.7 favored Devin. GPT models also produced notable recommendations for Claude, so the bias is not universal. The authors report consequential recommendation flips between model generations from the same lab and provide Opus→Fable and Sol→Astra comparison pages.
Stability differs by model: In the Sol→Astra and Opus→Fable comparisons, the median number of sources was 9 for Sol, 5 for Astra, 11 for Opus, and 15 for Fable; the authors describe Astra as more “confident” or “efficient” and less likely to change its answer after a light paraphrase. A practical evaluation pattern is therefore to compare coding-agent recommendations across model families, current model generations, and lightly paraphrased prompts rather than trusting a single model’s recommendation. The study cautions that its sample is small and reflects scraped attempted tool calls rather than pretraining data; Gemini/Antigravity, GLM/Zcode, and DeepSeek/DeepCode were excluded because of errors and rate limits.
- Salvatore Sanfilippo’s contrarian model-level view is to separate the AGI label from practical coding capability: he says current AI still lacks complete overlap with human abilities and genuinely novel breakthrough invention, but may mark the beginning of AI overlapping with complex skills such as programming and already performing some economically important tasks very well. For coding-agent evaluation, the practical implication is to measure concrete programming performance and task value rather than wait for an AGI threshold.
- Sanfilippo speculates that overcoming context-window limits may require fundamentally different Transformer context management, such as combining a rich embedding/residual-stream representation with another stream capturing the model’s overall state and details. He explicitly presents this as possibly necessary—or possibly unnecessary—and offers no implementation or benchmark, so this is an architectural hypothesis rather than a replicable agent workflow.
- Firsthand workflow — Simon Willison: For a phone-recorded demo video he wanted to publish on his blog, Willison asked Claude Fable 5.1 in Claude Code for web to “build me this tool,” using a WebAssembly build of FFmpeg; the linked Claude session is available for reference.
- The generated browser compressor supports five size/quality presets, configurable output dimensions, CRF, audio bitrate, encoder speed, H.264 profile, a 30-fps cap, metadata stripping, audio removal, and first-10-seconds-only encoding. Its reported run generated five versions in 11.8 seconds; the smallest was 145 KB, or 48% of the original.
ThePrimeagen is experimenting with models that use an application through desktop interaction and predicts that, by 2027, this approach could replace many Playwright tests by crawling and operating the app directly. He says his current Omarchy experiment shows the approach is “shockingly powerful” and harder to reproduce with scripts, making model-driven desktop testing an emerging alternative to scripted end-to-end tests.
- Local model layer: Fireship recommends Ollama for downloading and running open-weight models through a local CLI/API, keeping prompts private and eliminating per-inference cost; the trade-off is that frontier-scale models may require data-center-class hardware.
- Routing and cost control: The video’s “Nouter” router exposes one local OpenAI-compatible endpoint and supports fallback tiers: an existing subscription first, a cheaper paid model second, and free providers third. It also tracks usage and compresses tool output.
- Context management: Headroom sits between the agent and model provider, compressing tool outputs, logs, and other low-value context before it becomes billable input; the compressed material is cached locally and can be retrieved if needed, making the compression reversible.
- Coding-agent orchestration: Fireship presents OpenHands as an open-source autonomous coding agent that can work through GitHub issues, run continuously as a self-hosted “army” of agents, and use OpenAI, Anthropic, or locally hosted Ollama models. It is described as a top performer on SWE-bench Verified, but no score or reproduction details are provided.
Simon Willison used GPT-6 Astra (medium) in ChatGPT Work to build an animated D3 visualization that morphs between Mercator and Equal Earth; the resulting tool supports a slider and play button for exploring the transition. This illustrates a practical rapid-prototyping pattern: give a coding agent a narrowly defined visualization request, specify the implementation library (D3), and have it produce an interactive artifact.
- In a firsthand build, ThePrimeTime creator assembled the Omachi automation as a client-server system: cloud agents run through Cursor, Linear tickets track work and trigger actions, PlanetScale stores logs and actions, and Sentry measures session details to diagnose slow model behavior.
- The workflow reduced an effort that would have taken “a couple weeks” of manual tuning and testing to approximately two days with agent-assisted development.
- The practical takeaway is to optimize agents for real product outcomes—smooth, repeatable user experiences and security improvements—rather than treating generated demos or new model releases as the primary goal.
Addy Osmani describes a selective, risk-based code-review workflow:
- Run a multi-agent first pass on every PR to find bugs, verify findings, rank severity, and suggest fixes; keep final approval human for consequential changes.
- When a change has low blast radius and touches less-sensitive code, skip deep human review after the agent review is clean.
- Require an owner and human sign-off for core or sensitive paths, concentrating human effort on verification, constraints, trust, and recoverability—agents handle the first pass while humans cover blast radius.
Launch-day stability pattern (firsthand): Ahead of Kody’s launch, Kent C. Dodds asked Cloudflare and “Cursor/Grok/bot” to keep things running smoothly so he could make necessary adjustments and handle support, while separately requesting no major code changes for a while.
- AI game-building loop (Riley Brown): Build a game with an AI agent, ask it to add multiplayer, then share a link with friends for immediate playtesting.
- Secondhand multimodal demo: A quoted post claims GPT-6 Astra recreated a 10-acre estate from a PDF in Blender, added it as a playable map to a Call of Duty-style game built the previous day, and added a flyable, shootable helicopter from one prompt.
Model behavior comparison — Theo: GPT-6 Astra has produced both “incredible things” and some of the “stupidest things” Theo has seen from a model, while Fable 5.1 generally “just does what I ask.” This is a qualitative signal of high capability but inconsistent behavior from Astra versus more predictable instruction-following from Fable 5.1.
- Always-on local-agent pattern: Riley Brown says he is getting a Mac mini to run Codex 24/7 and wants one computer signed into everything he uses. He wants Codex running on his personal Mac with access to his browser, iMessage, files, and desktop apps; he says this has “closed the loop” on many daily activities and is making him consider running Astra profitably 24/7. This is a firsthand plan and observation, not a measured productivity result or confirmed completed deployment.
Kent C. Dodds offers a contrarian mindset for AI-assisted development: when developers feel that hand-writing code is being taken away, they should try to fall in love with solving problems rather than with manual code production.
Geoffrey Huntley reports a concrete agent-assisted 3D workflow: seven hours into attempting a 1:1 rebuild of Australia in Unreal Engine from ArcGIS data, Astra found Blender already installed and used it to “vibe code” the protagonists. The practical pattern is to let an agent inspect the local environment and reuse available creative tools for asset generation before adding installation or setup work.