How I Use GPT-5.6 Sol After ~30B Tokens of Experience

Summary

The speaker shares “best practices” for using GPT-5.6 Sol after extensive usage (~30B tokens). The focus is on:

• Selecting reasoning levels
• Understanding “loops” (and using sub-agents to build loop-like workflows)
• Using computer-use automation for system and non-coding tasks
• Key pitfalls/warnings where GPT-5.6 can struggle

---

1) Reasoning levels: what to use (and what to avoid)

Key recommendation

• Do NOT use the “Ultra” reasoning level (the speaker marks it red).
  • They claim it’s a waste/scam-like option with low upside due to heavy cost/inefficiency.

Recommended reasoning choices

Low (light) reasoning — best for execution / computer tasks

• Best when the task is well-defined and you want the model to execute steps quickly.
• Example: using Codex/Pi for one-off system actions (e.g., hard-resetting Raycast on macOS 27 beta rather than manually navigating terminals/menus/settings).
• Benchmark-style claims from the speaker:
  • ~45% performance for Low reasoning
  • Much cheaper, typically fewer steps (e.g., ~23 steps/task) than higher levels

Medium reasoning

• Described as an “improvement” over Low, but also a weird middle:
  • slower without reaching full power of High
• The speaker uses it less, mentioning Pi for tasks needing more thought but not “full high.”

High reasoning — default for most work (especially coding)

• The speaker’s default: GPT-5.6 Sol on High reasoning (not fast mode).
• Presented as the “sweet spot” for speed/cost/quality.
• Benchmark claims mentioned:
  • High ~69%
  • higher ~71%
  • max ~73%
• Caveat: cost/time/output growth becomes large at the top end.

Fast mode — keep it off most of the time

• The speaker recommends turning fast mode off most of the time.
• Reason: it increases rate-limit usage substantially.
• They also claim Ultra/Fast early on caused rapid depletion of usage allowances (e.g., 5-hour/weekly windows).

X high / Max reasoning — use sparingly

• Suggested only for big complex, undefined tasks with a clear end goal.
• Example: porting a web app to React Native + Expo
• Otherwise, prefer High due to diminishing returns.

---

2) “Loops”: what they are and how to use them practically

The speaker references the viral “loops” concept, but clarifies their approach:

“Loops” (their framing)

• “Loops” can mean many things, but the speaker focuses on baby loops via sub-agents.
• They contrast this with fully autonomous “big workflows” like:
  • PR/issue loop → planner → implementer → reviewer → PR bot → repeat until green

Preferred pattern: sub-agent orchestration for coding workflows

A practical workflow they like:

1. Planner sub-agent (creates a plan)
2. Implementer sub-agent (writes code)
3. Reviewer sub-agent (adversarial review)
4. Continue a PR loop until tests/reviews are green

Concrete example workflow (“feature PR implementation”)

They describe structured prompting like:

• “Implement feature on a new branch and make a PR.”

Behavior described:

• Main thread spawns the sub-agents (planner → implementer)
• Then both:
  • push commits / open PR
  • run a reviewer sub-agent
• They also rely on external PR review bots (e.g., Greptile, Code Rabbit, Macroscopic, Cursor) and feed review updates back into the main loop when issues arise.

Bonus: mixing harnesses/models

They describe chaining tools/harnesses such that different sub-tasks use different models/harnesses (planner vs implementer vs reviewers), while PR bots supply additional feedback.

They also mention building a Pi extension to spawn Codex or Cloud Code instances from a Pi thread.

---

3) Sponsor/Review tooling: Greptile improvements

The speaker promotes Greptile, highlighting two features:

1) T-Rex system (run-and-verify code review)

• Instead of only judging from code text, T-Rex runs code and logs actions.
• Example described:
  • It performed steps like producing proof for a positive finding, applied fixes, pushed updates, and reached a 5/5 confidence score via its review loop.
• Goal: improve correctness for complex PR changes by executing and validating.

2) Greptile CLI improvements

• Allows triggering a review for a branch without manual PR pushing.
• Supports an agent-driven workflow: an agent triggers review, receives feedback/info, and continues looping.

Value assessment:

• The speaker claims Greptile’s signal is high—especially with T-Rex.

---

4) Computer-use and non-coding automation

The speaker argues that GPT-5.6 + computer-use is now viable for non-coding tasks, including:

• system management
• network management
• debugging operational workflows

Example: debugging a crashing/lagging web flow

They used Codex desktop app with computer-use to investigate a browser app (Helium) and Amazon ordering.

Reported behavior:

• inspect rendering states
• reload sessions
• check extension status
• identify the issue as the Helium accessibility renderer/compositor being “wedged”
• restart the renderer and restore a session split to fix it

Example: media repair / creative apps

They mention a story (“Phase Theo”) where Codex fixed a corrupted video render in Final Cut using terminal/system actions.

Example: home server / network provisioning

They used computer use + Codex to:

• set up SSH passwordless access across devices
• transfer configs (e.g., ZSH, Pi, Codex/Cloud Code configs, dev directories)
• manage remote systems

They also mention:

• Tailscale for device connectivity
• a home-server Linux-hosted T3 Code instance

Practical advice: “Just ask the model”

For setup tasks:

• copy-paste a video URL + timestamp into Codex
• ask for a starting plan based on your current environment

---

5) Pitfalls / warnings (where GPT-5.6 struggles)

Main warnings cover:

• over-automation
• unclear instructions
• design limitations
• code quality differences compared to Fable

A) Code/design still needs oversight

• Even with GPT-5.6, the speaker notes it can still make weird decisions.
• Real projects require reviewing code for quality and scalability.

B) Over-extended work (“flying off the rails”)

If prompts leave gaps, the model may:

• fill intent in unintended ways
• spend huge time/tokens on edge cases

Personal incident:

• an “almost all day” attempt to build a complex Hermes agent runner (custom VM/testing/edge cases)
• later replaced with a much simpler Docker approach that was orders of magnitude cheaper (far fewer tokens)

C) Design capability: macro generation is weak

They tried generating thumbnail ideas and found outputs clearly unusable.

They also found the Codex harness had bad design system prompts (e.g., overusing green/cards).

Remedy described:

• guide design by breaking it into smaller parts
• provide references/images
• edit specific UI elements interactively
• compose assets themselves (e.g., SVG elements) and assemble in an editor like Affinity

D) Comparison vs Fable: elegance vs speed

The speaker claims:

• Fable often produces more concise/beautiful code
• GPT-5.6 is more of a “workhorse”

Example: Effect code

• Fable produced more elegant Effect/Generator-style code
• GPT-5.6 produced functionally correct results but with “gross” extra try/catch nesting and messy error handling in that scenario

However:

• if GPT-5.6 is given clear framework/patterns (including the “shape” of Effect architecture), it can perform well and sometimes faster than Fable.

E) Ultra and sub-agent cost explosion

They explain Ultra as effectively:

• max reasoning + sub-agents enabled
• sub-agents inheriting massive thread history

Result:

• huge context replication (e.g., 100k-token history loaded into multiple sub-agent threads)
• therefore, they consider it not worth it

---

Main speakers / sources (at end)

• Main speaker: The YouTube video author (unnamed in subtitles; speaking in first person throughout)
• Referenced tools/sources/companies:
  • Greptile (including T-Rex; CTO quote attributed to Brex)
  • Codex, Pi, Cloud Code
  • T3 code, Tailscale
  • Raycast, Helium, Amazon
  • PR review bots: Code Rabbit, Macroscopic, Cursor
  • Apple editor example: Final Cut (via Phase Theo reference)
  • Claude code (for comparison of the “loops”/workflow concept)