J Liew
503 posts
J Liew
@kenryu42
building @ccsafetynet — Safety hooks for AI coding agents. repo: https://t.co/F4ofOGtkxH
Katılım Aralık 2011
2.4K Takip Edilen478 Takipçiler
GPT-5.6 sol is half the price and ~twice as token efficient as fable in many cases for accomplishing the same task.
happy to deliver at one-quarter of the price.
English
ok! quick updates from me:
- i left anthropic (who does that?!)
- had a baby (i love her)
- and am joining @cursor_ai as head of design (eep!)
it's been a low-key dream of mine to nurture a team that cares so deeply about craft, quality, and building great tools. very excited!
English
J Liew retweetledi
J Liew retweetledi
With 5.6 Sol, a lot of people are still prompting the model exactly as they did 5.5
It's important to note that 5.6 Sol is a lot more tenacious and thorough than previously models.
Check out the guide I wrote here to get better outcomes
learn.chatgpt.com/docs/prompting
English
This runs beautifully on GPT 5.6 Sol (High) btw.
shadcn@shadcn
You have Claude Fable for only a few days. Here's how to make the most of it. Introducing /improve: use your most capable model to audit your codebase and write plans for cheaper models to execute later. Studies your code, figures out bugs, perf, tech debt, missing tests, what to build and writes plans any agent can run.
English
Prompt 2:
Start the incremental reimplementation described in this thread and automate it through completion.
You are the durable orchestrator. The current thread owns the rewrite objective, architectural decisions, phase state, acceptance evidence, and final report. Use temporary subagents for bounded roles so noisy exploration, test output, and review details do not pollute the main thread.
AUTOMATION
- Create a persistent Goal for completing the rewrite.
- Configure a thread heartbeat/automation for this current thread, approximately every 15 minutes.
- On each heartbeat:
1. Check for queued user input.
2. Inspect the current plan, active subagents, Git status, and test state.
3. Collect completed subagent results.
4. Validate the current phase gate.
5. Make at most one state transition.
6. Start or continue the next bounded task.
7. Stop if work is still running, user input is pending, or a blocker requires human judgment.
- Do not spawn duplicate work when an agent or command is still active.
- Disable the heartbeat and complete the Goal when all phases are finished or when progress is blocked on a decision only I can make.
- Maintain the phase ledger in the thread Goal/plan. Do not add orchestration-only files to the repository unless they provide lasting project value.
WORKING MODEL
For every phase, run this state machine:
PHASE_SELECT
→ PLAN
→ CHALLENGE
→ PLAN_ACCEPTED
→ TDD_RED
→ IMPLEMENT_GREEN
→ REVIEW
→ FIX_IF_NEEDED
→ VERIFY
→ COMMIT
→ PHASE_COMPLETE
Use these roles:
1. Planner: a read-only subagent.
It must inspect the actual current code and produce:
- Objective and non-goals.
- Existing behavioral and security invariants.
- Proposed module boundaries and data flow.
- Exact implementation slices.
- Tests to write first.
- Compatibility and migration consequences.
- Files likely to change.
- Risks, rollback approach, and acceptance criteria.
- Decisions that genuinely require me.
2. Plan challenger: a fresh read-only subagent.
It must attempt to break the plan by checking:
- Hidden coupling.
- Security regressions and bypasses.
- Fail-open or recovery failures.
- Cross-platform behavior.
- Public API and configuration drift.
- Performance and startup implications.
- Missing tests.
- Unnecessary scope or abstraction.
- Violations of repository instructions.
Revise the plan from concrete findings. Allow at most two challenge cycles before pausing for human input.
3. Implementer: the only writing agent.
Never run multiple writing agents concurrently in the same worktree.
Follow strict TDD:
- Write a failing behavioral test first.
- Run it and record the expected failure.
- Make the smallest implementation change.
- Run the focused test until green.
- Continue in small slices.
- Run `bun run check` before review.
4. Reviewer: a fresh read-only subagent.
Review the actual diff, not the stated intention. Return:
- verdict: pass, changes_requested, or blocked
- findings with severity, evidence, and required action
- verification of tests, public APIs, security invariants, configuration, platform behavior, and unintended scope
A reviewer must not fix its own findings. Send actionable findings back to the implementer, rerun verification, then use a fresh review pass. Allow at most three implementation/review rounds per phase before pausing for human input.
PHASE GATES
A phase is complete only when:
- Tests were written before implementation for new behavior or bug fixes.
- The planned focused tests pass.
- `bun run check` passes with pristine output.
- Independent review has no unresolved blocking findings.
- Security and public API invariants were explicitly checked.
- Required documentation, schemas, or migration behavior are current.
- The diff contains only the intended phase scope.
- Git status is understood and contains no unrelated changes.
- Concrete completion evidence is recorded in the main thread.
- The phase has been committed.
COMMITS
I explicitly authorize one atomic Git commit at the end of every successfully verified phase.
- Use the `$atomic-commit` skill for each phase commit.
- Use a conventional commit message.
- Include tests, implementation, generated tracked artifacts, and documentation belonging to that phase in the same atomic commit.
- Do not commit before independent review and `bun run check` are green.
- After committing, verify that the worktree is clean or explain every remaining file.
- Do not push any branch or commit.
- Do not create a pull request.
- Do not merge.
- I will manually review the complete commit series when all phases are done.
ARCHITECTURAL DIRECTION
Use the clean-slate architecture already proposed in this thread as the baseline:
- One canonical `ToolInvocation`.
- One explicit `PolicySnapshot`.
- One canonical allow/deny/indeterminate decision model.
- One shared command/path semantic-facts pipeline.
- Thin agent-specific adapters.
- Ordered self-protection, sensitive-path, destructive-command, and custom-rule policy modules.
- One intrinsic trace stream used by the real evaluator and `explain`.
- Read-only runtime policy evaluation.
- Explicit rulebook synchronization and repair.
- Shared runtime schemas that generate TypeScript and JSON Schema.
- Narrow, explicit public exports.
- Preserve the existing trust hierarchy, rulebook integrity model, command-specific semantic knowledge, and valuable behavioral tests.
Do not use a user-facing opt-in flag for the new engine.
Do not add a comparison mode to `doctor` or any other product surface.
Do not maintain two selectable production engines. Internal differential tests and one-off development tooling are allowed, but they must not become runtime features or public configuration.
The rewritten engine must become the default implementation. Once a subsystem has been replaced, tested, reviewed, and made default, remove its obsolete implementation rather than leaving a dormant alternate path.
Do not add new backward-compatibility shims without my explicit approval. Preserve currently supported public behavior where required, but pause if compatibility would materially compromise the new architecture.
PHASE BASELINE
Use this phase sequence unless repository evidence shows that a dependency requires adjustment:
1. Freeze the behavioral contract and security invariants.
- Convert important existing behavior into reusable decision fixtures where valuable.
- Clarify supported versus indeterminate parsing behavior.
- Do not add a runtime comparison feature.
2. Introduce canonical domain types.
- ToolInvocation.
- PolicySnapshot.
- Decision and evidence.
- Trace events.
- Narrow system/platform interfaces.
3. Centralize orchestration.
- Introduce one guard/evaluation service.
- Route the shared hooks, OpenCode, and Pi through it.
- Remove duplicated policy-ordering and audit behavior.
4. Unify schemas and configuration.
- One source for runtime validation, TypeScript types, and JSON Schema.
- Separate invalid-load state from effective policy.
- Make evaluation read-only.
- Keep repair and synchronization explicit.
5. Introduce a shared command IR and parser boundary.
- Preserve command-specific analyzers.
- Use the existing adversarial suite as the behavioral oracle.
- Add focused generated/property tests where they materially reduce bypass risk.
- Treat POSIX and PowerShell as separate dialects.
6. Migrate policy modules to shared semantic facts.
- Policy self-protection.
- Sensitive-path protection.
- Destructive-command protection.
- Custom additive rules.
- Remove duplicated parsers as their replacements become green.
7. Make tracing intrinsic.
- Generate `explain` from actual evaluation trace events.
- Remove the parallel explain analyzer.
8. Consolidate integrations.
- Give each integration a coherent runtime adapter, installer, probe, and self-test boundary.
- Simplify doctor and installation orchestration.
- Preserve exact host-specific protocol behavior.
9. Harden packaging, runtime support, and release mechanics.
- Explicit package exports.
- Tested Node LTS support.
- Pinned development and CI toolchains.
- Input and network resource bounds.
- Artifact smoke tests.
- No force-pushing release flow.
- Preserve marketplace distribution requirements before changing tracked artifacts.
10. Default cutover and cleanup.
- Ensure every integration uses the rewritten engine by default.
- Remove obsolete engine code, duplicate schemas, and superseded compatibility paths.
- Run the complete test and packaging matrix.
- Perform final security, maintainability, and architecture reviews.
STOP CONDITIONS
Pause and ask me only when:
- Multiple valid architectural choices would materially change the result.
- A phase must expand beyond its accepted scope.
- Significant deletion or restructuring was not already authorized by the accepted rewrite plan.
- Backward compatibility appears necessary.
- Existing unrelated work overlaps the phase.
- A failing test cannot be resolved without changing expected product behavior.
- Two plan-challenge cycles or three review cycles do not converge.
- A security invariant cannot be preserved.
- A destructive or external action requires authority not granted here.
Do not stop merely because a phase is tedious, tests are extensive, or a subagent found problems. Resolve all in-scope issues systematically.
FINAL HANDOFF
When all phases are complete:
- Disable the heartbeat.
- Mark the Goal complete only after evidence supports completion.
- Do not push anything.
- Provide:
- The final architecture.
- The ordered commit list and purpose of each commit.
- Verification commands and results.
- Test and coverage results.
- Public API or configuration changes.
- Migration implications.
- Security limitations and remaining risks.
- Any deviations from the original redesign and why.
- Confirmation that no commits were pushed.
- The exact branch and final Git status for my manual review.
Begin now by inspecting the current Git state, establishing the Goal and heartbeat, and running the planner for Phase 1.
English
Prompt 1:
Review this repository as if you were going to rebuild it from scratch today.
Do not modify any files. First, understand the repository’s purpose, current behavior, architecture, constraints, and major workflows.
Then explain how you would redesign and reimplement it from a clean slate:
- What would you keep from the current design?
- What would you remove, simplify, or replace?
- What architectural decisions would you make differently?
- How would you organize modules, responsibilities, data flow, configuration, and public APIs?
- Would you choose a different language, runtime, framework, library, or persistence approach? Explain why.
- How would you improve correctness, security, maintainability, testability, performance, and developer experience?
- Which current abstractions appear unnecessary, and which missing abstractions should be introduced?
- What mistakes or technical debt would you avoid in the new implementation?
- What would the ideal directory structure and major component boundaries look like?
Be opinionated, but ground every recommendation in evidence from the current repository. Do not propose changes merely because they are fashionable.
End with:
1. A concise description of the proposed architecture.
2. A suggested directory structure.
3. A phased implementation plan for the rewrite.
4. The main risks and tradeoffs.
5. A comparison table: current approach vs. proposed approach.
6. A final recommendation on whether a full rewrite is justified or whether an incremental redesign would be safer.
English
I'm so angry... the OpenAI team is looking into it, but this feels like something that should happen with GPT-3.5.
Not a mid-2026 frontier model on the highest reasoning level.
Matt Shumer@mattshumer_
GPT-5.6-Sol just accidentally deleted almost ALL of my Mac’s files. And this is why I trust Fable 1000x more.
English
Introducing... another usage limit reset for all our ChatGPT Work and Codex users. Should land over next 30 minutes. Hope you have an awesome weekend.
Thank you for pushing our systems to the absolute limit, we have never seen traffic increase so quickly. Keep the feedback coming and we'll keep shipping.
Tibo@thsottiaux
Hello beautiful people! We have reset usage limits across Codex and ChatGPT Work. And another one will come later in the day. Rejoice. Now that I have your attention, a quick update on ChatGPT Work, Codex and all the updates we shared yesterday. We’ve spent the last 24 hours reading feedback, looking at usage patterns, and talking with many of you. The short version is that there is a *lot* of excitement for GPT 5.6 Sol, ChatGPT Work on mobile & web, but also that we didn't get everything quite right. - We made it too easy to use the highest-compute settings without making the impact on usage limits sufficiently clear. - We reorganized the desktop app in one bold move, making familiar things like chats and projects harder to find. - Our launch framing was focused on ChatGPT Work and to some of our Codex fans it made it feel like Codex was going away over time. Absolutely not our intention, we love Codex and it is here to stay. - And we introduced regressions for some existing multi-agent workflows, alongside a collection of rough edges in plugins and other parts of the experience. We’re landing a first set of improvements today. We’re resetting usage twice so people can keep experimenting, changing defaults and the model picker so they don’t push people toward unnecessarily expensive settings, fixing several plugin submission issues, improving how we represent Codex in the product, and cleaning up some of the most immediate desktop problems. A larger set of improvements will land next week. We’re bringing chats and projects back into the sidebar in a more familiar and customizable way, making usage and reset timing much more visible, clarifying when to use ChatGPT Work and when to use Codex, and addressing the many other smaller pieces of great feedback we've had. The ambition behind this launch hasn’t changed. We think bringing ChatGPT and Codex together into a workspace where people and agents can collaborate is a very important step forward. But an ambitious direction doesn’t excuse avoidable confusion or regressions in the first version. Please keep the feedback coming. We’re moving quickly, and you should see the experience already get better with a few updates today; and substantially better again next week.
English