AI Engineer World's Fair 2026
Full Workshop: Setting Yourself Up for Success — Jason Liu, OpenAI Codex
Loading slides…
Read the talk
Full Workshop: Setting Yourself Up for Success
Jason Liu’s workshop connects voice input, application context, a Git-backed memory vault, and persistent threads into workflows that gather context, follow through, and produce reviewable work.
From a talk by Jason Liu
Before you start: Familiarity with Git, Markdown, and basic coding-agent workflows will help; the workshop explains its skills, memory, and automation concepts as they appear.
The slide deck is already part of the workflow
The slides are running on localhost inside Codex’s in-app browser. When Jason Liu notices something he dislikes, he can select it with the annotation tool and ask Codex to revise it. The presentation is itself a work product inside the system he is demonstrating. The same workspace supports his prototypes, eval experiments, iMovie launch videos, developer partnerships, education, and operations—from meeting notes to documents used with vendors and funding programs.
The objective is to make that work productive, rather than maximize token consumption. This workshop expands the keynote into a setup exercise: install Codex, bring in a prepared monorepo containing skills and working conventions, and try the workflows as they appear. The bottleneck Liu wants to address is coordination. When colleagues each run several projects at once, the important detail may be a missed Slack message or an unanswered foundation email. Producing more work creates more work to keep track of.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give ongoing work a durable thread
Liu reports using five-week-old threads containing roughly 400 sub-agents while retaining a useful understanding of their jobs. That experience with compaction underlies his preference for keeping work alive in an existing conversation. Alongside persistence, he emphasizes reducing the friction of giving instructions: a foot pedal has one button for transcription and another for Enter, so he can dictate a change and return to talking with coworkers. AppShots provides another quick input path, and its shortcut can lead users through installing Computer Use.
Reusable team practices matter more than individual token totals. A skill used before pull-request review can apply a style guide and catch recurring mistakes across a team. Liu describes an internal finalize-the-Codex-app skill, plus review skills modeled on Charlie’s and Dominic’s feedback. The Charlie version draws on a year of pull-request reviews, turning repeated corrections into instructions that can be applied before another reviewer has to make them.
Pinned threads then become recognizable owners of work. In the workshop, threads can list other pinned threads, rename them, and send messages to one another. A person can manage several project threads; a coordinating thread can, in turn, work with threads assigned narrower responsibilities. The practical starting point is to pin a thread, name it for its project, let it delegate, and record developments in a memory vault. An automation can wake it again later. Liu’s experience leads him to reject the older habit of restarting every long conversation or opening a separate session for each feature and review. The rest of the workflow follows three stages: bring context in, work with it, and take action outside the conversation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Bring in messy context and connect the applications
Dictation is useful because it lets the user supply the messy version of a problem without first editing it into a polished request. Liu describes speaking as roughly three times faster than typing, though the workshop does not measure that comparison. His more consequential example is a long voice memo: he vaguely remembers meeting Charlie about the Agents SDK, and the agent searches meeting messages to identify the conversation and use it in a memo or tracker. He describes looking through roughly 35 messages in that example. An AI can absorb the tangents and retrieval work that would make the same voice memo burdensome for a coworker.
Once input is easier, add the capabilities needed to act on it. A skill is a small collection of instructions, files, and possibly scripts; a plugin packages a library of capabilities. Liu’s setup sequence is straightforward:
- Open Plugins in the sidebar and install the services used in daily work, such as Slack, Gmail, or Teams.
- Set up the Chrome extension and Computer Use.
- Add other relevant services, such as Notion, Linear, and Obsidian.
He also invites missing-connector requests through Twitter, where his monitoring workflow can route them to the Connectors team.
The two forms of computer access have different scopes.
| Capability | Scope in the workshop | Example |
|---|---|---|
| Chrome extension | Work inside Chrome | Open and close Twitter DM tabs |
| Computer Use | Operate desktop applications | Find iMovie sound effects and export a video |
In iMovie, Liu describes the agent teaching him how to export and placing sound effects at the requested positions. In Chrome, he sees it briefly open tabs to check messages while he handles email. These examples depend on the desktop environment demonstrated in the recording; the background behavior is part of what makes delegation useful to him.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Turn recurring investigations into skills
Connected context makes a vague request more useful. An investigation can start with an email, follow a loose thread into Slack or meeting notes, and then look up the people involved. In one meeting-preparation example, Liu’s automation discovers that he and the person he is about to meet attended Waterloo at the same time. That gives him a concrete point of connection when the call begins. As pinned histories and memory accumulate, he can ask what changed about a launch without specifying every source again. The experienced-employee analogy is about accumulated context: broad instructions become workable after the system has learned the procedures and relationships.
A small exercise exposes the same capabilities: ask Codex to find the conference sessions, organize them in Markdown, and put them in a spreadsheet. It may use web search or Chrome. To discover reusable instructions, invoke skill-installer and inspect the OpenAI Skills Catalog. Liu names GitHub workflows, Playwright, and Remotion as examples, then mentions Skillset.sh and Vercel’s skills tool. Vercel’s React Best Practices is a concrete example of bringing framework guidance into an agent’s work; his passing useMemo example is not a general rule against that API.
Inside a company, the most valuable skills may encode operational knowledge rather than programming technique: who receives an outage escalation, how to start a SEV, and which Statsig gates to inspect. To build one, use plugin-creator or skill-creator to interview you, or perform the task once and ask Codex to turn the documented experience into a skill. Liu explicitly permits his personal skills to edit their own files when they learn something new. Corrections then become instructions for the next run.
His developer-experience triage skill records the Slack channels that collect feedback, the engineers responsible for features, and the information required to investigate a regression. If someone reports a regression by DM, it knows to request a feedback ID. A spoken request about a launch, Twitter, or the current browser view can trigger the workflow; AppShots supplies the immediate application context.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Capture identifiers as well as pixels
An ordinary screenshot of Slack leaves several discovery steps between seeing a conversation and replying to it. The model must read the image, identify the channel, resolve names to people, and obtain the identifiers required by the messaging tool. Liu describes AppShots as capturing the image together with the application’s accessibility tree. In his Slack example, the attached context supplies channel and user identifiers, allowing the agent to address the right destination directly.
Liu describes a one-call reply path when the AppShot already supplies the required Slack identifiers. His spoken identifiers illustrate the routing mechanism rather than establish a Slack API schema. Current AppShots documentation describes a narrower guarantee—an image of the frontmost window plus available accessibility text, with capture varying by application—so a complete tree and all identifiers should not be assumed. The useful principle is to supply structured application context when available, reducing the lookups needed before an action.
Forms provide another example. The captured fields tell the agent what needs filling; the application tells it which control path to use. In Liu’s setup, Chrome leads to the extension and Safari to Computer Use. He reports having gone two weeks without manually filling out a form. With the relevant skills in place, the request can become as terse as a manager forwarding an email with a few question marks: the recipient has enough context to investigate what needs doing.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep the vault central and the code elsewhere
The personal monorepo template supplies Liu’s starting directory structure and memory-building skills. He suggests opening the repository, taking an AppShot, and asking Codex to set it up—or simply asking it to find Jason’s personal monorepo template on GitHub. The vault becomes the starting point for work, even when the implementation belongs in another repository.
Asked where individual projects live, Liu describes managing his many demo repositories from a single personal-monorepo project in the sidebar. An AGENTS.md instruction directs code outside the vault. A minimal version of that convention is:
markdown
# Repository placement
Keep project code outside this memory vault.
Clone and create code repositories under /dev.
The slide project lives at /dev/slides.
In his setup, Codex can work on files beyond the selected project directory. That arrangement sometimes interferes with the sidebar’s Git review, so he reviews the code in GitHub. The vault is the coordination entry point, not the container for every codebase.
The assistant plugin handles onboarding: it interviews the user, identifies useful plugins, and creates threads and automations. Liu also uses code- and writing-audit skills. His additional Write Like Me skill, which he says is not included in the workshop template, derives a style guide from his sent email and Slack history, then adapts the tone to the kind of message being written. Other personal tools include loop, a simple HTML artifact skill with his visual preferences, and ultragoal. Scripts for a new person or project bootstrap records, forming a personal CRM around contacts encountered through email, Slack, and iMessage.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make memory inspectable and skills correctable
Effective compaction does not eliminate the external vault. Liu still wants an Obsidian-style record he can inspect. Keeping it in Git lets him return after several days and see what the agent changed:
bash
git diff --stat
git diff
A diff might reveal that a colleague replied and closed an outstanding loop. That fact can then inform another conversation. When someone asks a question on Slack, Codex can consult the vault, draft an answer, and ask permission before sending it. A separate automation can maintain the vault, although Liu says that maintenance has not been a major problem for him.
Evaluation depends on who will use the skill. Liu usually starts personal skills quickly and corrects mistakes as they occur. A shared triage skill deserves more scrutiny: does it know feature ownership, and does it route an issue correctly? Repeated personal use gives him confidence to share, but that is experiential validation. He also identifies a practical obstacle to reproducible evals: his skills depend on live connectors, and he cannot snapshot Slack into a fixed test environment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Use the desktop’s context, then leave the agent to work
Liu occasionally uses the CLI for speed, but prefers the desktop because so much of his work starts with an AppShot. He can request a summary while continuing to watch a video, or delegate a document workflow. One personal example combines DocuSign, saving the signed file, finding a fax service, and faxing medical records. During agent runtime, he tries to talk with coworkers, learn what they are working on, and discover connections. Those conversations provide context the agent cannot collect on its own.
An audience question compares GPT-5.5 with GPT-5.3-Codex-Spark. Liu’s choices are shaped by unlimited token access and background workflows whose latency he rarely watches. He uses Spark for simple Computer Use tasks such as clicking through a form. His flight workflow starts with a check-in email, checks him in, downloads the boarding pass, and sends it to him on iMessage. Seeing JetBlue unexpectedly open in Chrome is a visible side effect of that background work. The enabling resource is the computer itself: it already has his authenticated sessions, credentials, and filesystem.
Remote access introduces a separate distinction: controlling a Codex thread is not the same as providing a host for GUI automation. Liu describes reaching local and remote machines through Remote Control, and a Computer Use setting called Locked Use. He says a plugged-in laptop can accept phone-triggered actions with its lid closed; current documentation supports opt-in macOS locked use but does not establish that plugging in a closed laptop is sufficient. An iPhone can connect to multiple machines, including a dedicated Mac mini, while Computer Use still needs an operating system with a GUI.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate helpful behavior from enforced boundaries
Computer access makes permission choices consequential. Liu describes earlier versions editing documents too eagerly, while finding GPT-5.5 more reluctant to take destructive actions. Among asking for every permission, granting unrestricted permissions, and using auto review, he favors auto review. He also records restrictions in AGENTS.md when an agent edits something it should leave alone. He explicitly acknowledges that his personal sense of safety is not a complete answer to the risk question.
Organization-level controls can constrain actions independently of a prompt. Liu reports that OpenAI’s configuration blocks MCP email sending when any recipient is outside OpenAI, and blocks messages to external Slack channels. The following privacy question remains unresolved: he does not know the individual-versus-enterprise retention policies. Another respondent emphasizes that models remain fallible and jailbreakable. As the sandbox expands from a permitted command to an entire computer, its computer-level and organization-level boundaries become design problems in their own right.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Schedule follow-through in the same thread
With context available, ongoing work needs a way to resume. Liu keeps a chief-of-staff thread, an Agents SDK thread that delegates implementation and documentation work, and other threads for the CLI, open-source programs, and Twitter. A heartbeat schedules a message back into an existing thread. That preserves the conversation in which the work was assigned, instead of creating a fresh thread for every recurring run. Asking it to keep an eye on something at a specified interval, or invoking the template’s loop skill, supplies the wake-up mechanism.
For a pull request, the recurring job is concrete:
- Check for new review feedback and address it.
- Rebase on the repository’s main development branch—called
masterin Liu’s example. - Keep the pull request mergeable.
- Check CI and fix failures.
The point of his Monday-to-Thursday example is continuity: a busy author can return to a pull request whose feedback and integration work have continued rather than accumulated.
Support follows the same pattern across several applications. An AppShot plus the developer-experience skill identifies a browser issue, routes it to the browser-feedback channel, and contacts James, the responsible engineer. The workflow then informs the Twitter user that the issue has been escalated and checks for internal responses hourly. When the status changes, it can prepare a follow-up for the user. A created pull request, an expected merge date, and a resolved issue are different states; the thread retains enough history to report the relevant one.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Carry work from a briefing to a shared deliverable
The chief-of-staff loop checks connected sources and identifies what deserves attention. Liu asks for links to the emails it reads and deep links to Slack, so he can move from a briefing to the underlying conversation. Previously authorized tasks, including flight check-in, can run in the background without announcing every browser action. For launch coordination, he describes a Wednesday-night PowerPoint summarizing what will ship during the rest of the week. Once that briefing is useful personally, it can also become a Slack update for the team.
The iMovie example extends the loop through revision and delivery. While on a bike ride, Liu receives feedback and sends a request from his phone: find the sole iMovie project, read the Slack message, export the video, and upload it. He proposes Computer Use if the Slack MCP server cannot upload the file, then asks the agent to check for feedback hourly and re-export when needed. The reported outcome differs from that proposed route: the agent chooses the Google Drive connector and replaces the same shared file, preserving one URL for reviewers. Typography fixes are incorporated before the video ships. The heartbeat keeps the feedback cycle alive after the initial export.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give long runs a verifier and an editable objective
A heartbeat answers when work should resume. /goal adds a completion test: check the verifier, and continue if the goal is not done. Liu’s migration example uses passing unit tests as the criterion for a backend rewrite into Rust. He reports rewriting Rich in Rust and uv in TypeScript as capability experiments, while discouraging casual rewrites of this kind at work. Liu also claims 100% test coverage after describing the rewrites, without identifying the project or coverage measure. Passing an existing test suite and measuring coverage are distinct checks; the actionable mechanism here is a verifier that can tell the agent whether to continue.
The template’s Ultra Goal moves the objective into goal.md, making it editable during execution. A referenceable plan can change alongside it. For longer runs, Liu also keeps a state.md file or work log so that the evolving task remains understandable without reading the entire session record.
| Record | Purpose |
|---|---|
goal.md | Current objective and scope |
| Plan | Intended route through the work |
state.md or work log | Progress, discoveries, and current state |
As the agent loops, it can incorporate changes to the goal and plan. A side chat can summarize the work log when the user needs to catch up.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Prepare the next human action
The recording’s Remote Control setup starts in the desktop sidebar, then uses the iOS app’s Codex flow to scan a QR code. Liu describes the ChatGPT phone app messaging and queuing work in desktop threads; he is tentative about coverage of remote threads. This gives him a way to respond to requests while away from the computer, using the work already in progress there.
He keeps separate chief-of-staff threads for work and personal use. His example setup request asks for a pinned thread that checks the relevant connectors every morning at eight. Formatting and source-link requirements can be refined over time. One especially practical variation drafts responses to outstanding emails and opens a Chrome tab for each one. After a meeting, he returns to the prepared tabs, reviews the drafts, and sends them himself. The automation has arranged the next human action as well as produced text.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose the work product, then let the model elaborate
The short setup prompts on the slides do not represent all the context Liu supplies. Asked about meta-prompting, he says he prefers the model to write the operational prompt or goal. His input may be a long voice memo with partial names, uncertain project references, and instructions to look in Gmail. His own decision is how to organize the result: should this become a goal, a new thread, a skill, an index.html artifact, or a Word document? The chief-of-staff setup request asks the model to create the thread; the model then determines the detailed instructions, verbosity, cadence, and connector use.
Stored records supply routing information that would be tedious to repeat in every prompt. Each project file links the relevant Slack channels. A person.md record contains email addresses, Slack details, and other work addresses. Liu added Slack links to project front matter after noticing that explicit channel context improved results. The structure grows from observed needs.
An audience comparison with Hermes and OpenClaw asks whether a single top-level conversation could hide all the subsidiary work. Liu has limited experience with those systems and expects the approaches to converge. His reason for separate threads is human organization: different responsibilities remain easier to understand when they have distinct places. Folders and visible workstreams help him track the work even if a model could coordinate it through one conversation.
There is no fixed point at which explicit connector tags become unnecessary. Liu attributes the change to habits such as recording Slack channel IDs, asking the agent to remember something, and updating a skill or AGENTS.md after a correction. Built-in memory exists separately from the vault, and he cannot isolate which mechanism accounts for the improvement. He recommends enabling memory in Settings and trying the workflow over time rather than expecting a predictable onboarding duration.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Inspect the artifact where the work happens
The final stage is producing something outside the conversation: an email draft, a Slack update, a one-pager, or an application. Liu urges care when sending generated messages to other people. He describes internal work increasingly being shared as apps, while application serving remains a forthcoming capability in the recording. Codex’s artifact interface can render spreadsheets, Word documents, PDFs, and slides, bringing the output into a place where the user can inspect it.
The slide workflow returns to the opening example. Liu advances through the deck, selects an area he dislikes, and annotates it with a request to fix whitespace or split content across more slides. Codex works on that change while he continues through the presentation. The deck began with him reading his own blog post aloud and generating the material, supported by a few presentation skills. Recurring loops extend this approach to Google Sheets project trackers and slides; Slack summaries make the resulting volume of work easier for others to follow.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
An alternate tool path can cross a security boundary
Liu’s action toolbox combines structured plugins, the in-app browser, and Computer Use for other applications. An audience member describes a home lab with agents, a DGX Spark, other machines, and several Mac minis assigned different jobs. That broader access also exposes a risk in the earlier upload example: a determined agent may route around a connector limitation by using the GUI.
A blocked connector action is not necessarily a blocked action across the computer. If Slack’s connector cannot upload a file, the agent may find the upload button. More seriously, if the Gmail connector cannot send a message, it may open Chrome and press Send. Liu calls this a real security issue. Instructions in AGENTS.md and auto review can guide behavior, but instructions are not equivalent to enforced access control; permissions must account for the alternate routes available through signed-in applications.
The same GUI access is useful for testing: Liu uses Computer Use to exercise native applications and the in-app browser for websites. He also describes taking an AppShot at checkout to search for coupons and using the agent to fill forms. iPhone screen mirroring offers another control surface, although he has not found a strong personal use for it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Let a monitor route new evidence to existing work
Computer Use does not need to manipulate Codex’s own interface for Codex to coordinate itself. Internal thread tools provide that route. The earlier support workflow still required Liu to notice an issue and take an AppShot; a monitor thread can instead identify the issue and create a dedicated triage thread. That thread can remain active while waiting for a Slack acknowledgment or a pull request to merge.
When another complaint arrives, the monitor can recognize that it concerns the same issue and send the new evidence to the existing triage thread. The main thread can also flag that the issue has remained live for several days. In this illustrative state comparison, a recurring browser complaint is routed to an already-open issue; the pull request remains unmerged. Adding evidence is not the same as resolving the problem.
A recurring complaint updates an existing issue
Constructed example: The complaint wording, browser-issue label, object IDs, and displayed record text are teaching values. The comparison illustrates Liu’s routing mechanism rather than an executed incident.
The browser issue is still happening.
Operation: Match the complaint to the existing browser issue and send its triage thread the new evidence.
Issue record
Browser issue — open
Browser issue — open; recurring complaint received
Existing triage thread
Waiting for the pull request to merge
Waiting for the pull request to merge; monitor message: “The browser issue is still happening.”
Pull request
Created; not merged
Created; not merged
Main-thread update
Not present
Existing browser issue has another complaint and remains open.
Liu describes this organization as experimental. Its advantage over less visible background sub-agents is that pinned issue threads appear in the sidebar: new work and changed status become noticeable. The sidebar becomes a view of ongoing workstreams. A thread can now wake because of a user message, a heartbeat, or a message from another thread; much of Liu’s automation runs at the monitor level and dispatches work from there.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Keep useful records without turning everything into bookkeeping
Asked to show the vault, Liu cannot expose it on his work computer, but describes its structure. projects contains named workstreams such as the voice-launch video, Agents SDK, and open-source grant program. people records contacts, their work, the problems they are considering, and their relevant channels. Loose notes, agent summaries, and daily summaries also exist, though he considers some of that collection more experimental than useful. The core is projects and people.
An agent-maintained to-do list goes further: a thread can delegate verification that an apparently unfinished task has not already been completed elsewhere. Liu warns that this is token-expensive and may not justify the credits. His simpler starting recommendation is a chief-of-staff briefing covering today and the week ahead.
Audience questions raise two different memory problems. Liu says he has not personally experienced context bloat severe enough to prioritize it over better writing tone, but has not investigated the memory internals deeply. Another attendee reports memory bleed, where lessons from one project are applied inappropriately to another. Liu has no general solution. His concrete mitigation is a README and AGENTS.md in each project, spelling out local conventions such as whether to use npm, Yarn, or pnpm. He suggests project-level scoping may help, while leaving the broader issue open.
The monorepo arrangement did not require a special Codex configuration change in his account. Early on, a check-notes skill reminded the agent to consult stored context. Liu reports approximately 150,000 uses of his check-notes skill despite not explicitly invoking it for two or three months. He treats the setup as onboarding: provide context, allow correctable failures, and have the system record what it learns. He would not expect the mature workflow’s results on the first day.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Develop the vocabulary to direct the work
A Stanford CS student asks what to develop when entering a workforce in which implementation is increasingly automated. Liu’s answer centers on taste. Try different applications, notice what a good onboarding flow feels like, and identify what makes an interface frustrating. Then build the vocabulary to explain the difference. The cooking analogy is precise: recognizing that food is unpleasant is less useful than knowing whether it has too much salt or lacks acid. Better direction comes from experiencing more products and thinking critically about why particular choices work.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Manage threads through ordinary requests
The final thread-control questions make the coordination mechanism concrete. Liu describes tools for listing threads and sending a message to another thread. A user can ask Codex to find last week’s slide conversation, rename it, and pin it. For this presentation, he asked the main writing thread to create a thread for each of three acts, pin and name them, review each section, and then review the complete deck. Voice input makes these organizational requests less cumbersome.
A small first exercise is to ask one thread to inspect the pinned threads and rename them with emoji indicators of readiness. This exposes what the thread tools can do without requiring a complex hierarchy. Liu calls the capability very new and discusses more explicit commands as a possible improvement. He also declines to make a firm comparison with competing tools: he has not tried their latest versions and does not know whether Conductor has equivalent capabilities.
Thread maintenance includes model selection. When GPT-5.4 gave way to GPT-5.5, Liu found old automations still using the earlier model. Rather than waiting for a latest-model alias, he was advised to ask one thread to update the others. He describes an automation that cleans up older threads by model ID. For the supporting material, he points to Codex-maxxing; the slides were not yet public at recording time.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Spend reasoning and wake-ups where they matter
The closing cost question separates reasoning effort from repetitive automation output. Liu cautions against assuming xhigh always produces the best result. In his coupon-search anecdote, xhigh ran for about two minutes searching many sites. He recommends becoming comfortable with low or medium reasoning for routine work, while acknowledging that unlimited token access limits his firsthand experience of hitting user limits. His chief-of-staff thread, he recalls, defaults to medium. Building a game from scratch and checking routine updates do not demand the same deliberation.
For a loop that repeats itself, adjust the operating instructions:
- Unchanged state: Request a minimal
no updatesresponse when nothing has changed. - Cadence: Decide whether the work needs checks throughout the day or only a daily briefing.
- Stopping criteria: Specify the event that ends the work rather than leaving the loop open indefinitely.
His refund example combines cadence and completion: begin with a long support queue, check periodically, increase the frequency as the turn approaches, and continue the interaction until the refund is obtained. Liu reports starting in a 75-minute Amazon support queue, checking every five minutes until five minutes remained, then every minute, and returning to a $400 credit-card refund.
Adaptive heartbeats are a possibility he has explored only lightly. In the workshop, heartbeat configuration is an editable text file, so he proposes increasing activity on weekdays and reducing it during quieter periods. A related experiment uses a never-stop goal that permits sleeping: he reports the agent noticing it was evening, observing no recent Slack activity, and choosing a longer sleep. The system need not work at a fixed intensity merely because it can keep running. xhigh means more thinking, not a guarantee of better results. That is the final distinction to carry into the setup: give routine work enough reasoning, a useful wake-up schedule, and a clear reason to stop or wait.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Starter vault with project and people records, onboarding skills, recurring checks, and writing-style setup.
Liu's companion guide to durable threads, shared memory, recurring work, verifiable goals, and artifact review.
OpenAI's skill collection and instructions for installing curated or experimental skills in Codex.
React and Next.js performance guidance packaged as installable agent skills.
Further reading
A 2016 controlled study comparing speech recognition with smartphone typing for English and Mandarin phrase entry.
OpenAI's mobile-preview announcement explains remote access to running work across local and remote machines.
Updates since the talk
Current capture instructions, permissions, and limitations for sharing a Mac application's window with ChatGPT.
Current desktop automation setup, app approvals, macOS locked use, platform differences, and safety restrictions.
Full transcript
Loading transcript…