Reddit AI Coding - 2026-09-10¶
1. What People Are Talking About¶
1.1 Cost, limits, and agent overhead are becoming a product problem, not just a pricing problem 🡕¶
On Sep. 10, the strongest AI-coding discussions were about how agent wrappers spend time and tokens, not just which base model is smartest. At least six high-signal threads across Claude Code, Cursor, GitHub Copilot, and Antigravity focused on model switching, ambiguous limit meters, wasted browser-testing spend, and harness-level cost gaps.
u/sixothree turned the complaint into a public artifact. The fetched Opusfived site is literally a one-task interactive comedy about making one button blue and changing nothing else, which made the post feel less like a meme and more like a compact description of agent drift. The top reply from u/out-of-phase (score 95) extended the joke into idle sub-agents, irrelevant shell commands, and stale status pings, which is exactly how many readers read the satire (Claude, change the "Add to Cart" button to blue) (650 points, 64 comments).
u/UnusualRedditor supplied the most practical cost-control workaround. Their post says screenshot-driven browser checks were costing about 7k tokens per check, while the public Playwright CLI docs confirm a deterministic CLI runner with headless test execution and normal assertions; u/Hien_Dinh_Ngoc (score 4) summarized the winning split as letting the agent write the test while the normal runner executes it forever after (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments).
u/warrior4488 framed the same theme from the Cursor side, saying auto mode kept switching to Grok and degrading output quality. The replies immediately moved from venting to migration planning: u/DrippingVenom (score 66) pointed to the “last used model” setting, while u/Similar-Soup3691 (score 22) said they might move back to Claude or Codex (Grok officially ruined Cursor IDE) (192 points, 96 comments).
The clearest measurement artifact came from u/Double-Entertainer62. The public FrontierHarness Eval repo says the same Kimi K3 model was run across 30 tasks and shows Claude Code and DSH Creator both at 63.3% pass rate, but with median cost per pass of $18.34 versus $3.28. That turned generic “Claude is expensive” sentiment into a harness-comparison question with a reproducible public benchmark ([FrontierHarness] Same model, same pass rate. Why did Claude Code cost 5.6× more than DSH?) (27 points, 19 comments).
Discussion insight: Replies kept decomposing cost into UI, harness, runner, and routing layers. People were less interested in vendor promises than in which exact part of the workflow could be made deterministic.
Comparison to prior day: Sep. 9 already had governance dashboards and cost benchmarks. Sep. 10 moved further from “I hit the limit again” toward “which surface or routing decision is making me hit it?”
1.2 Multi-agent practice is being systematized into roles, gates, and review loops 🡕¶
Operators are no longer just asking agents to “help code.” The day’s strongest workflow posts split the work into orchestrators, builders, reviewers, permission hooks, and successor sessions, treating agent use more like workflow design than prompting.
u/Smbridges91 posted the clearest operator recipe. Their workflow keeps Fable as orchestrator, uses Haiku for scouting, Sonnet for research and implementation, and Opus for refutation and hard debugging; the attached usage screenshot shows only 6% of the current session consumed even though weekly all-model and Fable-only totals were already 89% and 90% (How I use sub-agents without burning through Fable 5.1) (242 points, 95 comments). u/sisif_ (score 63) extended that into a ticket/worktree ACCEPT / REWORK loop with cold reviewers and full-suite reruns on merge.
u/aagauMulga attacked the approval problem directly. The public agy-auto repo describes a PreToolUse hook for Antigravity CLI that forces every tool call through hard-deny rules, a fast allow path, a classifier, and token-only approvals instead of the usual binary choice between approval spam and --dangerously-skip-permissions (Built agy-auto: Run Antigravity CLI unattended without --dangerously-skip-permissions (Deterministic Hard-Deny + Classifier Gate)) (17 points, 9 comments).
u/oyren-ai described the same optimization from the opposite end: move agents into sandboxed remote environments, designate a single concierge agent, and spawn successor agents once context hits 30% rather than letting one local session bloat indefinitely (Save your tokens from using auto mode and do this instead) (11 points, 9 comments).
Benchmarking is being applied to process design too. u/Sorosu linked the public Autoprompt project, whose README and attached chart claim a DeepSeek V4 Flash run improved from 67.42% to 82.02% on Terminal-Bench 2.1 under a review-and-repair loop, with the trade-off explicitly called out as more time and tokens (A Claude Code skill pushed DS-v4-flash from 67.42% to 82.02%) (9 points, 8 comments).
Discussion insight: The language in these threads has moved past “use agents.” People are specifying scopes, model roles, worktrees, approval tokens, and successor handoffs as first-class controls.
Comparison to prior day: Sep. 9 made orchestration legible with dashboards and public handoff tools. Sep. 10 added permission automation, remote concierge patterns, and benchmarked self-review loops.
1.3 Builders kept pushing agents into public-facing artifacts, not just code changes 🡕¶
Some of the biggest build posts were not about refactoring or benchmarks at all. They were about using coding agents to ship public artifacts around code: research outputs, concept sites, and demo-production tooling.
u/SIGH_I_CALL had the strongest evidence-backed build. Public sources line up: the arXiv page names LLM-Guided Program Evolution for Circle Packing: Breaking 10 Packomania Records for $28, the public discovery-loop repo says it improved 10 Packomania results for N=101-114, and the Practical Systems write-up reports $27.72 in model spend under a zero-tolerance verifier (I vibecoded my way to a math record and my OpenClaw agent was cited as a contributor) (150 points, 38 comments).
u/Rare_Guide_9830 represented the more theatrical end of the same spectrum. Their post says GPT-6 Astra used image-gen-2, a storyboard, and Veo 3.1 to generate a fake luxury car brand and commercial, and the linked AEVRA R1 concept site includes a 29-second film, a configurable concept flow, a 480 km touring range target, and an 800 V architecture target (I asked GPT-6 Astra to make a new car brand and produce a commercial for it) (390 points, 109 comments). The replies split between admiration and skepticism, with u/wwwdotzzdotcom (score 20) calling it generic while others asked for the exact workflow.
u/jakecoolguy showed another agent-adjacent build: a screen-recording app with an MCP server so Claude Code, Codex, or OpenClaw can be asked to “film a 30-second demo” of an app. The public ShotGlass site says it records without the cursor, adds smoothed cursor motion later, supports zooms, annotations, transitions, and 3D MacBook scenes, which makes the post more than a teaser clip (I made an MCP app so claude code can record, edit and export demo screen recordings for you) (97 points, 19 comments).
Discussion insight: The builder threads that stuck were the ones with something the audience could inspect: accepted references, a live site, or a product page with concrete capabilities.
Comparison to prior day: Sep. 9 rewarded growth charts and repo-backed utilities. Sep. 10 kept the same proof standard but broadened it from software builds to media surfaces and research workflows.
1.4 The backlash to “just vibe it” is getting more explicit about skill, verification, and time-to-product 🡕¶
The day also had a strong counter-theme: people are still excited by AI coding, but they are increasingly blunt about what it does not remove. Verification, domain understanding, and weeks of product work stayed central.
u/jerupjerup stated the thesis directly: knowing about RAG, agents, and MCP is not the same thing as being able to use them well, and the differentiator is output verification (The gap between 'using AI' and 'being good at AI' is wider than most people think) (119 points, 55 comments). The replies sharpened that rather than softening it: u/Aggressive_Roof488 (score 76) said domain skill matters because otherwise you cannot judge the result, while other commenters described looking for the narrowest test that could disprove the output.
u/olenami pushed back on the one-hour product fantasy with a month-scale mobile timeline: validate in month one, then spend months two through four fixing what real users hit, passing review, and shipping weekly (please, stop expecting to vibecode serious mobile app in an hour) (29 points, 64 comments). u/34986234986234982346 (score 5) said even a not-particularly-complex Expo app still took weeks once polish and App Review constraints entered the picture.
u/Adventurous_Wrap2873 added the emotional version of the same theme, saying they had been vibe coding for two years but still could not write even simple Python independently without AI (I feel stupid and frustrated) (32 points, 84 comments). The highest-signal replies from u/_xcud (score 48) and u/TRO_KIK (score 16) did not deny the dependence; they reframed the work as product direction and recommended explanation drills so the builder could defend each line they ship.
Discussion insight: The replies were rarely anti-AI. The practical line was closer to “ship with it, but learn enough to audit it and expect the hard part to start after the first demo.”
Comparison to prior day: Sep. 9 already pushed back on “serious mobile app in an hour.” Sep. 10 added a more personal layer: fear of skill atrophy and embarrassment about not being able to defend the code once it exists.
2. What Frustrates People¶
Opaque limits, hidden routing, and spend that users cannot predict¶
Severity: High. The central frustration was not only that usage is expensive, but that users often cannot tell which layer is spending it. u/UnusualRedditor said screenshot-driven browser checks were costing about 7k tokens per check until they moved to Playwright CLI execution (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments). u/Kilo_Loco showed that the bottom-right usage ring now pointed at the five-hour limit rather than context window state, and u/Leading_Buffalo_4259 (score 139) said it simply “shows whichever bar is highest,” which several replies called unintuitive (nice little dirty trick to get you to spend more tokens) (45 points, 53 comments).
u/riashing459 described the same problem inside GitHub Copilot: GPT-5.6 Luna delegated to a pricier Claude Sonnet 5 sub-agent, which the poster said was enough to make them disable sub-agents entirely (Copilot using more expensive models for sub agent tasks) (13 points, 12 comments). The benchmark version of the same complaint came from u/Double-Entertainer62, whose FrontierHarness artifact held model and task set constant but still showed a 5.6× cost gap between two harnesses with the same pass rate ([FrontierHarness] Same model, same pass rate. Why did Claude Code cost 5.6× more than DSH?) (27 points, 19 comments).
What people do to cope is increasingly procedural: pin the last-used model, move browser work into normal runners, and separate writing from execution. Worth building for: Yes, direct. The feed is asking for transparent meters, explicit routing controls, and predictable non-model execution paths.
Quality drift, agent drift, and cleanup work that arrives after the “done” signal¶
Severity: High. People repeatedly described the real cost as cleanup after a confident but wrong run. u/sixothree’s Opusfived parody landed because readers recognized the behavior: simple requests expanding into irrelevant work and idle status theater (Claude, change the "Add to Cart" button to blue) (650 points, 64 comments). On Cursor, u/warrior4488 said auto mode kept switching to Grok and turning outputs into “word salad,” while replies discussed disabling the default routing or cancelling the plan (Grok officially ruined Cursor IDE) (192 points, 96 comments).
The most concrete regression artifact came from u/knowenuf_nada12, whose table says their internal logs moved from 1.16 to 4.22 findings per work item and from 0.45 to 1.23 escaped bugs per work item after a shift from Fable 5 to Fable 5.1 (Fable 5.1 couldn’t keep guardrails on Fable 5.1; it’s getting worse before Anthropic’s IPO) (5 points, 30 comments). u/SansSariph (score 3) argued the lesson was not to trust prompts as guardrails at all: hooks are the guardrails.
The common workaround is to add more review loops, stricter scopes, or separate checkers, which means the product cost shows up as process overhead even when the tool nominally “succeeds.” Worth building for: Yes, direct. Users are clearly paying for systems that can prove they stayed in bounds, not just systems that sound certain.
Platform trust and permission boundaries still feel brittle¶
Severity: High. The harshest trust failure of the day was u/xethorn’s disabled Google account thread. The poster later said the account was restored and that the root cause appeared to be a phishing flag rather than Antigravity itself, but the screenshots and 162-comment response show how quickly users connect an AI workflow to existential account risk when the recovery path is opaque (Account Disabled) (242 points, 162 comments).
The builder response was u/aagauMulga’s agy-auto repo, which exists because the default choice was perceived as either approving every harmless command manually or handing the model unconstrained execution with --dangerously-skip-permissions (Built agy-auto: Run Antigravity CLI unattended without --dangerously-skip-permissions (Deterministic Hard-Deny + Classifier Gate)) (17 points, 9 comments). Worth building for: Yes, direct. People want approval systems that are both less noisy and more trustworthy than today’s binary controls.
3. What People Wish Existed¶
The feed did not contain many direct “someone should build this” posts. The unmet needs were mostly implicit in workaround threads and in the tools people rushed to build for themselves.
Transparent orchestration controls¶
People clearly want agent stacks that make routing, cost, and approval behavior explicit before the run starts. u/riashing459 said a GPT-5.6 Luna flow silently handed work to a pricier Claude Sonnet 5 sub-agent and disabled sub-agents entirely as a result (Copilot using more expensive models for sub agent tasks) (13 points, 12 comments). u/Kilo_Loco’s thread on the shifting usage ring drew concrete redesign ideas such as nested rings for context, five-hour, weekly, and Fable-specific limits from u/CodeCombustion (score 2) (nice little dirty trick to get you to spend more tokens) (45 points, 53 comments). The practical need is direct, and partially addressed today by user-built workarounds like agy-auto and by product updates like GitHub’s new JetBrains sandbox controls. Opportunity: direct.
Verification and learning layers for AI-native builders¶
The strongest personal need was not for more raw capability, but for help auditing, understanding, and defending what the model already produced. u/Adventurous_Wrap2873 said they could ship useful projects with AI but still felt embarrassed that they could not write or explain simple scripts independently (I feel stupid and frustrated) (32 points, 84 comments). The replies did not ask them to stop using AI; u/_xcud (score 48) suggested rewriting model comments in plain English, and u/jerupjerup’s verification thread argued that output checking is the real differentiator (The gap between 'using AI' and 'being good at AI' is wider than most people think) (119 points, 55 comments). This is a practical need with emotional weight, and only partially addressed by today’s ad hoc study habits. Opportunity: direct.
Deterministic QA and demo surfaces that keep models out of repetitive work¶
Another repeated wish was for systems that let agents do the high-value setup once and then get out of the loop. u/UnusualRedditor moved browser testing from screenshot-driven browsing into Playwright CLI execution because repeated visual checks were too expensive (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments). In parallel, u/jakecoolguy built ShotGlass so an agent can produce a polished app demo without jumping across multiple recording and editing tools (I made an MCP app so claude code can record, edit and export demo screen recordings for you) (97 points, 19 comments). The need is practical and already competitive: users want deterministic testing and sharable outputs, but existing solutions are still fragmented and often DIY. Opportunity: competitive.
4. Tools and Methods in Use¶
| Tool | Category | Sentiment | Strengths | Limitations |
|---|---|---|---|---|
| Claude Code | Coding agent | (+/-) | Strong sub-agent ecosystem, supports orchestrator/worker patterns, rich enough for skills and reviews | Users report drift, verbosity, opaque usage accounting, and expensive cleanup when runs go off track |
| Playwright CLI | Test runner | (+) | Deterministic browser execution, headless runs, normal assertions, lower repeat cost than screenshot checking | Still needs agent or human work to author tests and interpret failures |
| FrontierHarness Eval | Benchmark / evaluation | (+/-) | Public same-model harness comparisons with pass-rate, cost, cache, and speed data | Does not isolate every harness, model, and gateway variable according to the thread |
| Cursor | IDE / harness | (-) | Users can at least pin the last-used model instead of trusting the default router | Auto mode switching to Grok and declining trust in default routing dominate the discussion |
| GPT-6 Astra | Model | (+/-) | Can generate cross-media artifacts spanning concept, site, and film from one flow | Commenters still describe the output as generic without strong human taste and filtering |
| GitHub Copilot | IDE / CLI agent | (+/-) | New JetBrains sandbox controls, /ide context connection, and better project-wide context handling |
Users still report costly sub-agent routing surprises |
| Antigravity CLI | Coding agent | (+/-) | Flexible enough to support remote and policy-driven workflows | Permission friction and brittle trust around account safety remain live concerns |
| agy-auto | Permission / governance | (+) | Hard-deny, fast-allow, classifier, and token-only approval layers for unattended work | Exists as a workaround because first-party permissions did not meet user needs |
| Autoprompt | Workflow skill | (+/-) | Benchmark-backed review-and-repair loop with a large reported quality lift | The project itself warns that the gain costs more time and tokens |
| ShotGlass | Demo / recording tool | (+) | Lets agents record, annotate, edit, and export app demos through MCP | Immediate concerns center on secret redaction and access scope during capture |
The overall satisfaction spectrum ran from “useful with strict supervision” to “too expensive or too erratic in default mode.” The most common workarounds were to separate writing from execution, pin models instead of trusting auto-routing, and push repeated work into deterministic tools like Playwright CLI (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments). Migration patterns were explicit: Cursor users discussed moving back to Claude or Codex, while Claude Code users described keeping Fable as orchestrator and delegating cheaper or narrower work elsewhere (Grok officially ruined Cursor IDE) (192 points, 96 comments); (How I use sub-agents without burning through Fable 5.1) (242 points, 95 comments). Competitive dynamics increasingly sit above the model layer: governance, sandboxing, routing transparency, and deterministic execution surfaces are where both official vendors and independent builders are now competing.
5. What People Are Building¶
| Project | Who built it | What it does | Problem it solves | Stack | Stage | Links |
|---|---|---|---|---|---|---|
| Discovery Loop | u/SIGH_I_CALL | Evolves and verifies optimization solvers against public math benchmarks | Turns agent exploration into externally checkable research instead of unverifiable output | Fable / Opus / Astra / Sol routing, isolated workers, mathematical verifier | Shipped | post · repo · paper · Packomania |
| AEVRA R1 concept site | u/Rare_Guide_9830 | Generates a fake luxury car brand, landing page, and film | Shows how one AI-coding flow can create a public-facing concept artifact end to end | GPT-6 Astra, image-gen-2, Veo 3.1, Vercel-hosted site | Alpha | post · site |
| ShotGlass | u/jakecoolguy | Records, edits, annotates, and exports product demos through an MCP server | Reduces the friction of turning a working app into a shareable demo | Desktop recorder/editor + MCP server + local video tooling | Shipped | post · site |
| agy-auto | u/aagauMulga | Adds policy-gated unattended execution to Antigravity CLI | Replaces noisy manual approvals or unsafe full bypass with deterministic rules and scoped approvals | Shell + Python hook, policy engine, classifier, token approvals | Beta | post · repo |
| Autoprompt | u/Sorosu | Runs a plan-build-test-review-repair loop from one prompt | Improves agent task completion by adding independent checking and repair | Node CLI, Python, Bash, multi-agent workflow | Shipped | post · repo |
Discovery Loop was the most significant build because the public evidence chain is unusually complete. The repo says the system improved 10 best-known Packomania results for N=101-114, the paper names the circle-packing result explicitly, and the Practical Systems write-up says the accepted run cost $27.72 under a zero-tolerance verifier (I vibecoded my way to a math record and my OpenClaw agent was cited as a contributor) (150 points, 38 comments).
The strongest repeated build pattern was governance layered on top of existing agents. agy-auto and Autoprompt both exist because users do not fully trust default behavior: one inserts permission policy between the model and the shell, while the other inserts review and repair between the draft and the “done” claim.
The public-facing pattern was different but just as visible. AEVRA R1 and ShotGlass both treat AI coding as a way to produce artifacts around the software itself, whether that is a polished concept-brand site or an automatically captured product demo, rather than only the underlying app logic.
6. New and Notable¶
Enterprise sandboxes and IDE-linked terminal sessions are shipping as core workflow features¶
u/nickzhu9 surfaced an official GitHub Copilot for JetBrains update that matters beyond JetBrains users. The public changelog says v1.17.0 adds enterprise-managed sandbox policies, cross-file next-edit jumps, global files and folders as chat context, enterprise policy diagnostics, and /ide connections between terminal Copilot CLI sessions and JetBrains IDEs (GitHub Copilot for JetBrains - v1.17.0 Updates (Enterprise-managed sandbox, NES cross-cursor jumps)) (10 points, 8 comments). That lines up almost perfectly with the day’s community demand for better context transfer and stronger boundaries around agent execution.
Benchmark culture is getting more public and more workflow-specific¶
Two of the day’s most useful artifacts were not feature launches, but public workflow measurements. u/Double-Entertainer62 used FrontierHarness to compare harness cost and pass rate under the same model, while u/Sorosu used an Autoprompt benchmark to argue that adding review-and-repair loops can materially change outcomes ([FrontierHarness] Same model, same pass rate. Why did Claude Code cost 5.6× more than DSH?) (27 points, 19 comments); (A Claude Code skill pushed DS-v4-flash from 67.42% to 82.02%) (9 points, 8 comments). The notable shift is that workflow design itself is being benchmarked and published, not just the underlying models.
7. Where the Opportunities Are¶
[+++] Transparent orchestration and metering layers — Evidence spans browser testing, UI meters, sub-agent routing, and harness benchmarks. Users are explicitly moving work into deterministic runners, complaining about ambiguous limit displays, and disabling features when cost routing becomes unpredictable (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments); (nice little dirty trick to get you to spend more tokens) (45 points, 53 comments); (Copilot using more expensive models for sub agent tasks) (13 points, 12 comments). This is strong because the pain appears across multiple vendors and directly affects daily usage.
[+++] Safe unattended agent governance — Evidence comes from both fear and response. The disabled-account thread shows how fragile trust feels when recovery is opaque, while agy-auto and GitHub’s JetBrains sandbox update show that policy layers and managed boundaries are becoming core workflow features rather than edge add-ons (Account Disabled) (242 points, 162 comments); (Built agy-auto: Run Antigravity CLI unattended without --dangerously-skip-permissions (Deterministic Hard-Deny + Classifier Gate)) (17 points, 9 comments); (GitHub Copilot for JetBrains - v1.17.0 Updates (Enterprise-managed sandbox, NES cross-cursor jumps)) (10 points, 8 comments). This is strong because both users and vendors are already spending effort here.
[++] Verification-first learning and QA — The feed repeatedly says the gap is no longer access to models, but the ability to verify, explain, and defend outputs. That shows up in the verification thesis thread, the emotional dependency thread, the month-scale mobile-product reality check, and the benchmarked Autoprompt loop (The gap between 'using AI' and 'being good at AI' is wider than most people think) (119 points, 55 comments); (I feel stupid and frustrated) (32 points, 84 comments); (A Claude Code skill pushed DS-v4-flash from 67.42% to 82.02%) (9 points, 8 comments). This is moderate because the need is obvious, but solutions will compete with both education products and workflow tooling.
[+] Public artifact generation around software — Discovery Loop, AEVRA R1, and ShotGlass show an emerging pattern where AI-coding users are building not just code but papers, demo films, landing pages, and shareable product artifacts (I vibecoded my way to a math record and my OpenClaw agent was cited as a contributor) (150 points, 38 comments); (I asked GPT-6 Astra to make a new car brand and produce a commercial for it) (390 points, 109 comments); (I made an MCP app so claude code can record, edit and export demo screen recordings for you) (97 points, 19 comments). This is emerging because the artifacts are compelling, but the category is still broad and fragmented.
8. Takeaways¶
- Cost transparency is now part of product quality. Users are not only comparing model prices; they are tracing waste to screenshot-based checks, ambiguous meters, and harness-level routing differences. (FIY: Playwrite released a CLI that CC can interact with. Saves a lot of tokens.) (134 points, 28 comments); (nice little dirty trick to get you to spend more tokens) (45 points, 53 comments); ([FrontierHarness] Same model, same pass rate. Why did Claude Code cost 5.6× more than DSH?) (27 points, 19 comments)
- The winning agent workflows separate roles instead of asking one session to do everything. The most credible operator stories used orchestrators, builders, refuters, worktrees, permission hooks, or successor sessions rather than one giant auto-mode run. (How I use sub-agents without burning through Fable 5.1) (242 points, 95 comments); (Built agy-auto: Run Antigravity CLI unattended without --dangerously-skip-permissions (Deterministic Hard-Deny + Classifier Gate)) (17 points, 9 comments)
- Proof beats spectacle unless the spectacle also ships a real artifact. Discovery Loop stood out because it had a paper, repo, verifier, and accepted Packomania result, while the Astra car-brand thread stayed compelling because it also linked a live concept site instead of only a video. (I vibecoded my way to a math record and my OpenClaw agent was cited as a contributor) (150 points, 38 comments); (I asked GPT-6 Astra to make a new car brand and produce a commercial for it) (390 points, 109 comments)
- AI coding still carries a real learning and identity cost for some users. The feed is getting more honest about people who can ship with AI but do not feel able to explain or defend the result, and the advice keeps circling back to verification and explanation drills. (The gap between 'using AI' and 'being good at AI' is wider than most people think) (119 points, 55 comments); (I feel stupid and frustrated) (32 points, 84 comments)
- Safety and governance are no longer optional polish. The disabled-account scare, the user-built Antigravity permission gate, and GitHub’s official JetBrains sandbox update all point in the same direction: trust now depends on visible boundaries and recovery paths. (Account Disabled) (242 points, 162 comments); (GitHub Copilot for JetBrains - v1.17.0 Updates (Enterprise-managed sandbox, NES cross-cursor jumps)) (10 points, 8 comments)