What Grok 4.5 Actually Improves in X Search

Here are 5 notable X posts from the past 24 hours (July 12–13, 2026) on AI coding agents. I focused on substantive discussions, user tests, efficiency insights, scaling practices, and industry bottlenecks while excluding low-signal or purely promotional content. All are verified recent via timestamps. Direct X URLs use the format https://x.com/[handle]/status/[post_id].

1. @alsamahi (https://x.com/alsamahi/status/2076321639353262098) Summary: Most developers still use single AI coding agents, but top performers run 20+ (e.g., Claude Code & Codex) in parallel via separate git worktrees that auto-fix CI and handle reviews. Why it matters: Captures a practical shift toward massively parallel agent workflows, illustrating how early adopters are gaining significant productivity edges.[1]

2. @adriwtm (https://x.com/adriwtm/status/2076443080878600662) Summary: 54% better token efficiency in agentic coding isn’t just a benchmark—it makes longer inspect-patch-test-fix-verify loops affordable and viable. Why it matters: Quantifies real workflow math changes that could accelerate practical adoption of agentic coding beyond simple demos.[2]

3. @TaoTang1264919 (https://x.com/TaoTang1264919/status/2076458645609717926) Summary: Daily AI signals roundup highlighting Claude Code (33k tokens) vs. OpenCode (7k) context cost battles, production agent migrations to GPT-5.6 for speed/cost wins, OneDev AI embedding agents into dev pipelines, and team-shared agent memory/processes. Why it matters: Aggregates timely, specific competitive and integration developments showing agents moving from “it runs” to measurable production value.[3]

4. @viach_ai (https://x.com/viach_ai/status/2076450404498288927) Summary: Real-world testing of Grok 4.5 on coding + agent workflows shows strong token efficiency and speed, leading to pipeline switches from Claude. Why it matters: Provides grounded user feedback on a new model’s agentic performance, highlighting rapid iteration and model swapping in active workflows.[4]

5. @horbunovdima (https://x.com/horbunovdima/status/2076316748802851132) Summary: Weak models aren’t the main limiter—it’s fitting agents into human-centric processes/tickets/approvals. Only ~20% of devs actively use them; next gains will come from full SDLC integration (specs, architecture, testing, deployment) rather than isolated coding. Why it matters: Offers a clear-eyed analysis of systemic adoption barriers beyond raw model capability.[5]

These posts reflect emerging themes like parallel execution, efficiency metrics, production integration, and process-level changes in AI coding agents.

ELAPSED=25.27

Here are 5 genuinely notable recent X posts (from ~2026-07-12 to early 2026-07-13) about AI coding agents. These focus on benchmarks, real-world impact (including by high-profile users), cultural effects, extreme scale/usage, and practical tooling improvements. I prioritized substance, relevance, and engagement/insight over pure promo or low-effort hype. Timestamps place them within roughly the past 24 hours (GMT); engagement and content were cross-checked via search results. Direct URLs use the standard https://x.com/handle/status/ID format.1. Pietro Schirano (@skirano) URL: https://x.com/skirano/status/2076456519810580681 Timestamp: ~Sun 12 Jul 2026 23:59 GMT (very recent; video attached) Summary: Announces an improved site for exploring the Coding Agent Index. Highlights surprises like Terra Max slightly edging Fable 5 Max (77.4 vs 77.2) at ~76% lower cost per task, Sol XHigh nearly matching Max at ~26% lower cost, and Luna Max beating Opus 4.8 Max at ~80% lower cost. Why it matters: Delivers timely, data-driven comparisons of leading models/agents on coding benchmarks with strong emphasis on cost-efficiency. From an ex-Anthropic engineer and tool creator, this helps practitioners choose practical setups amid rapid model releases rather than chasing peak scores alone. Solid early engagement (dozens of likes, thousands of views, bookmarks).

2. Mario Zechner (@badlogicgames) URL: https://x.com/badlogicgames/status/2076367981802573954 Timestamp: Sun 12 Jul 2026 ~18:08 GMT Summary: Recommends Terence Tao’s fresh blog post (“Old and new apps, via modern coding agents”) on using coding agents to port ~24 of his ~1999 Java applets to modern JavaScript (plus building new ones). The agent completed the work in hours, revived complex visualizations (e.g., honeycombs with Allen Knutson), and even identified two bugs in Tao’s original code (Tao found only one minor new issue). Why it matters: Showcases a Fields Medalist successfully applying AI coding agents to real scientific/math software maintenance and creation—including verification/debugging of legacy code. Validates broader utility beyond everyday web/apps and has strong traction (65+ likes, high bookmarks). Confirmed via the linked Tao post itself.[1]

3. Axel Bitblaze (@Axel_bitblaze69) URL: https://x.com/Axel_bitblaze69/status/2076408608292745487 Timestamp: Sun 12 Jul 2026 ~20:49 GMT Summary: A vivid, humorous “warning” that Claude Code is so capable it “will ruin your life”—making other activities boring, leading to skipped sleep, desk dinners while watching agents work, and terminal replies to friends. Compares the pull to childhood gaming, except it builds real websites, bots, and businesses, and notes anyone can start. Why it matters: Captures the genuine cultural and personal transformation many power users report with advanced coding agents (addictive productivity, lifestyle shift). High relatability and engagement (50+ likes, thousands of views, replies echoing the experience) make it a notable pulse-check on real-world impact rather than dry tech specs.

4. Jeremy (@Jeremybtc) URL: https://x.com/Jeremybtc/status/2076456981829955697 Timestamp: Mon 13 Jul 2026 ~00:01 GMT (very recent; video attached) Summary: Shows Claude Code spawning ~100 agents and consuming ~3 million tokens in ~10 minutes on what is described as a simple task. Why it matters: Dramatically illustrates the current scale of parallelism and resource use in top coding agents—both their raw power for rapid multi-agent work and potential for extreme (sometimes inefficient) token burn. Sparks discussion on cost control, prompting strategy, and when massive agent swarms help vs. overkill. Timely and visually striking with replies debating efficiency.

5. sin-ack (@traits_reality) URL: https://x.com/traits_reality/status/2076407440392818929 Timestamp: Sun 12 Jul 2026 ~20:45 GMT (image attached) Summary: Introduces “agent-run,” a simple flexible tool (built over the weekend) for running coding agents in a proper sandboxed environment. Addresses common pain points like annoying permission pop-ups and inadequate sandboxing across various agents the author uses. Why it matters: Tackles a practical security and usability bottleneck for serious local/multi-agent workflows. Open contribution that improves safe experimentation without heavyweight setups; representative of the fast community tooling layer growing around core agents like Claude Code/Codex/Cursor-style systems. Decent early traction for a technical release.

These avoid pure product pitches or low-substance hype. Engagement is relatively modest overall (niche topic), but the selected posts stand out for insight, evidence, or demonstration of real capability/impact. Searches covered keyword + semantic queries with time filters (since ~2026-07-12), min-engagement, and specific notable angles; timestamps and content were verified via the results. Newer posts continue appearing, so the landscape moves quickly.

ELAPSED=69.18

1. Mon, 13 Jul 2026 00:21:00 GMT - https://x.com/samsaffron/status/2076461857758761013 - Questions whether the goal is restoring reasoning summaries or accepting the fix that removes HTML comments.[1]

2. Mon, 13 Jul 2026 00:11:45 GMT - https://x.com/samsaffron/status/2076459528720400390 - Suggests requesting reasoning summaries back via the linked OpenAI community thread, noting it’s inconsistently available only to paid API users.[2]

3. Sun, 12 Jul 2026 02:54:44 GMT - https://x.com/samsaffron/status/2076138157314339077 - Asks @pakrym for thoughts on whether the removal of reasoning summaries in Codex was intentional.[3]

4. Sun, 12 Jul 2026 02:04:31 GMT - https://x.com/samsaffron/status/2076125522363629712 - Highlights missing reasoning summaries in Codex and links to the OpenAI community discussion while tagging relevant users.[4]

5. Sat, 11 Jul 2026 22:15:22 GMT - https://x.com/samsaffron/status/2076067853955207288 - Complains that reasoning info is stripped in the ChatGPT provider but remains available in the official OpenAI API.[5]

ELAPSED=17.86

Latest 5 non-pinned posts from @samsaffron (newest first; includes replies).[1]

1. Timestamp: Mon, 13 Jul 2026 00:21:00 GMT URL: https://x.com/samsaffron/status/2076461857758761013 Summary: Sam notes it is unclear whether the goal is to restore reasoning summaries or simply accept the deployed fix that strips HTML comments.[1]

2. Timestamp: Mon, 13 Jul 2026 00:11:45 GMT URL: https://x.com/samsaffron/status/2076459528720400390 Summary: He urges people to request the return of reasoning summaries on the OpenAI community forum, saying he misses them and that the paid API still provides them while the ChatGPT provider does not.[2]

3. Timestamp: Sun, 12 Jul 2026 02:54:44 GMT URL: https://x.com/samsaffron/status/2076138157314339077 Summary: Sam asks @pakrym for thoughts on whether the removal of reasoning summaries (linking the community post) was intentional.[3]

4. Timestamp: Sun, 12 Jul 2026 02:04:31 GMT URL: https://x.com/samsaffron/status/2076125522363629712 Summary: He posts that he misses the reasoning summaries in Codex, links a community thread requesting them back, and CCs several people.[4]

5. Timestamp: Sat, 11 Jul 2026 22:15:22 GMT URL: https://x.com/samsaffron/status/2076067853955207288 Summary: Sam complains that the thinking/reasoning info is no longer present in the ChatGPT provider (though it remains in the official OpenAI API) and says he misses it.[5]

These are the most recent posts returned by chronological search (Latest mode) from the account as of the query time; none of the top results appear to be a pinned post (pinned posts are sticky and typically older when present). All include replies where applicable.

ELAPSED=25.48

Here are 5 substantive X posts from July 6–13, 2026, focused on PostgreSQL performance or internals. They emphasize original technical observations, benchmarks/patches, or incident lessons (sourced via keyword and semantic searches with date filters). I excluded promotions, tutorials, and ads. Direct links use the post IDs; dates are from the timestamps (GMT).

1. Ben Dicken (@BenjDicken), July 12, 2026 https://x.com/BenjDicken/status/2076303632799281253 Snippet: “Database performance and human efficiency are limited by the same thing: the universal scalability law. In a perfect world, throwing more cores at Postgres would scale performance linearly. Two problems: contention and coherency. Contention = some resources are shared across processes. Shared buffers. WAL. Synchronization and locking are required here, diminishing returns with scale. Coherency = data in shared resources must be consistent! CPU cache flushing. IPC. Disk sync. With enough going on, this reverses the effectiveness of increasing parallel work. This is one of N reasons why sharding a database becomes a necessary scaling axis with increasing QPS / data size.” Why worth reading: Deep, original analogy applying the universal scalability law to Postgres internals (shared buffers, WAL, coherency/contention), with practical implications for scaling and sharding. High engagement and clear technical insight.

2. alex shapalov (@alxshp), July 8, 2026 https://x.com/alxshp/status/2074992935662432407 Snippet: “PostgreSQL 19 performance work looks seriously interesting. → Parallel autovacuum → Dynamic async I/O workers → REPACK CONCURRENTLY → Better anti-joins → Broader incremental sort → Eager aggregation → Up to 2x faster inserts with foreign-key checks → Async I/O stats in EXPLAIN This is the kind of release operators feel. Less waiting. Less blocking. Better visibility. More control.” Why worth reading: Concise, high-signal summary of upcoming PostgreSQL 19 performance patches and features (autovacuum, I/O, sorting, aggregation, FK checks, EXPLAIN improvements) with operator-focused impact. Directly highlights patches and benchmarks.

3. Abhishek Singh (@0xlelouch_), July 8, 2026 https://x.com/0xlelouch_/status/2074783818909688224 Snippet (excerpt from top-10 list): “Top 10 mistakes devs make with PostgreSQL: 1) SELECT * in hot paths… 2) Missing composite indexes… 3) Not checking EXPLAIN (ANALYZE, BUFFERS)… 5) Connection per request, no pooling (pgBouncer)… 7) No statement_timeout / lock_timeout… 8) Ignoring autovacuum bloat… 9) Weak retry logic…” Why worth reading: Practical, experience-based list of common performance pitfalls drawn from real production patterns (indexing, EXPLAIN, pooling, timeouts, autovacuum, observability). Strong incident-lesson flavor without being generic.

4. Agasta (@idkAgasta), July 11, 2026 https://x.com/idkAgasta/status/2075997096000573490 Snippet: “One of the coolest things I’ve learned during GSoC has been PostgreSQL internals. We recently implemented a lazy migration strategy that added a new column to 22 million rows without locking up the production database. Wrote about how it works (and why this approach was much better than a table rewrite).” Why worth reading: Original technical observation on Postgres internals for zero-downtime schema changes (lazy migration vs. table rewrite on a 22M-row table). GSoC context adds credibility; focuses on locking and production impact.

5. Abhishek Singh (@0xlelouch_), July 8, 2026 https://x.com/0xlelouch_/status/2074814044591005711 Snippet (excerpt): “Senior production scenario for backend folks: You ship a Postgres migration at 2pm. It takes an ACCESS EXCLUSIVE lock on a hot table. p95 jumps from 40ms to 8s… What do you do in the next 5 minutes to recover safely… Constraints: you can’t drop traffic to zero… How do you prove it’s safe to cancel? What do you check in pg_stat_activity/pg_locks… redesign the migration (CONCURRENTLY, lock_timeout, statement_timeout, batched backfill…)” Why worth reading: Detailed incident-lesson walkthrough of a real-world ACCESS EXCLUSIVE lock migration failure, including diagnostics (pg_stat_activity, pg_locks), recovery steps, and prevention patterns (CONCURRENTLY, timeouts, observability). Highly actionable for operators.

ELAPSED=23.16

Here are 5 substantive X posts from roughly the past 7 days (2026-07-06 to 2026-07-13) focused on PostgreSQL performance or internals. I prioritized original technical observations, benchmarks, upcoming feature details, schema/migration lessons, and deep dives (via pageinspect, planner behavior, autovacuum cost models, etc.). I excluded job ads, generic tutorials, pure vendor pitches, and low-substance hype.[1]

1. Autovacuum cost drivers (benchmark)

• URL: https://x.com/PerconaBytes/status/2075497258481532941
• Date: Fri, 10 Jul 2026
• Quoted snippet: “Same dead-tuple count, 8.7x difference in autovacuum runtime. 360 benchmark runs on PG18 show the real cost driver is dirty pages, not dead tuples, and each redundant index adds a near-constant chunk of time.” (links to full Percona community blog with results)
• Why worth reading: Original multi-run benchmark isolating autovacuum internals. It challenges the common “just more dead tuples” mental model and quantifies the impact of dirty pages + redundant indexes. Directly actionable for vacuum tuning, index hygiene, and understanding why vacuum times vary so much in production.

2. Unique indexes do not store unique keys (heap visibility)

• URL: https://x.com/FranckPachot/status/2075262204090122728
• Date: Thu, 09 Jul 2026
• Quoted snippet: “🐘 Do you think unique indexes have unique keys? Not in PostgreSQL. 🤓 Let’s PageInspect heap and index tuples in a new blog post: [dev.to link on resolving uniqueness through heap tuple visibility]”
• Why worth reading: Clear, tool-assisted internals deep dive (pageinspect on heap vs index tuples) explaining how PostgreSQL actually enforces uniqueness under MVCC. Dispels a common misconception and is useful for anyone debugging unique constraint behavior, HOT updates, or index bloat.

3. Query planner parameters with prepared statements

• URL: https://x.com/FranckPachot/status/2074029072288518572
• Date: Mon, 06 Jul 2026
• Quoted snippet: “🙋 Should query planner parameters in #PostgreSQL be set for PREPARE or EXECUTE when using prepared statements? 🙋In EXPLAIN (SETTINGS), does the plan reflect the parameters in the ‘Settings’ section? 👉 New blog post: [dev.to link]”
• Why worth reading: Precise investigation of a subtle planner/GUC interaction that affects real prepared-statement workloads and EXPLAIN diagnosis. Helps avoid misdiagnosis of plans and clarifies when settings actually take effect—high practical value for performance troubleshooting.

4. PostgreSQL 19 performance work (operator-relevant features)

• URL: https://x.com/alxshp/status/2074992935662432407
• Date: Wed, 08 Jul 2026
• Quoted snippet: “PostgreSQL 19 performance work looks seriously interesting. → Parallel autovacuum → Dynamic async I/O workers → REPACK CONCURRENTLY → Better anti-joins → Broader incremental sort → Eager aggregation → Up to 2x faster inserts with foreign-key checks → Async I/O stats in EXPLAIN This is the kind of release operators feel. Less waiting. Less blocking. Better visibility. More control.”
• Why worth reading: Concise, production-oriented summary of concrete upcoming internals and performance improvements (parallel vacuum, async I/O, concurrent repack, insert speedups with FKs, better EXPLAIN stats). Good signal for what will actually reduce operational pain rather than marketing features.

5. Lazy column addition to 22M rows without locking

• URL: https://x.com/idkAgasta/status/2075997096000573490
• Date: Sat, 11 Jul 2026
• Quoted snippet: “One of the coolest things I’ve learned during GSoC has been PostgreSQL internals. We recently implemented a lazy migration strategy that added a new column to 22 million rows without locking up the production database. Wrote about how it works (and why this approach was much better than a table rewrite)” (links to Medium write-up)
• Why worth reading: Hands-on lesson from GSoC work on large-table schema changes. Contrasts lazy/default-based approaches vs full rewrites, focusing on lock avoidance and production safety. Excellent practical example of applying internals knowledge to avoid incidents on big tables.

These stand out for technical density over the period. Engagement varies (some deep technical posts get fewer likes than listicles), but the content quality matches the request. If you want follow-ups on any of the linked blogs, more posts from a specific angle (e.g., pure patches/commits or vacuum incidents), or expansion to threads, let me know.

ELAPSED=44.36

5 representative posts from experienced developers (self-identified senior devs, SWEs, engineers, or those describing production use) on X in the past ~48 hours about Grok 4.5 for coding:

1. @Bodok0 (Senior Software Engineer) URL: https://x.com/Bodok0/status/2076458803965432259 Short quote: “Grok 4.5 is by far the best model to write code. It’s extremely fast inference do actually have a huge impact on productivity. Use Fable to write the roadmap and write the APIs ahead. Then grok implements it…” Context: Senior engineer sharing workflow integration.

2. @nomanyaqubNY (active builder posting daily updates on projects) URL: https://x.com/nomanyaqubNY/status/2076454847780381021 Short quote: “I mostly use Grok 4.5 now. /goal is ridiculously good. Give it a well written plan dot md and it’ll plan, code, spawn sub agents, test, debug and iterate until the task is complete.” Context: Developer describing iterative agentic workflow.

3. @oppatunist (describes hands-on use with large production codebase) URL: https://x.com/oppatunist/status/2076419399456616844 Short quote: “I use Grok 4.5 on a production codebase of ~90k loc, and I have no retarded issues at all. Performance and token usage massively improved. It can read the entire codebase and get to work so quickly.” Context: User working directly with substantial real-world code.

4. @Robbie_Render (Senior Developer) URL: https://x.com/Robbie_Render/status/2075982067762864411 Short quote: “As a Senior Developer, I think Grok 4.5 is still fucking stupid, but it’s less stupid than it was last week. I still wouldn’t trust it to write me a codebase. It’s OK with snippets, like AVX2 optimisations. I still don’t think my job is at risk from these chatbots.” Context: Self-described senior dev in a thread discussing model comparisons.

5. @quiet_node (Sr SWE @Hashgraph, builds AI/tools) URL: https://x.com/quiet_node/status/2076460970059120783 Short quote: “@XFreeze There’s this weird bug man I’m using Grok Code CLI v0.2.99. The subagent shows grok-4.5 but when I tell the subagent to print out what actual model it uses, then it shows weird names. Sometimes it’s Gemini sometimes it’s Composer but sometimes it shows correct model names.” Context: Senior SWE reporting specific CLI/subagent issue with screenshots.

Synthesis distinguishing evidence from vibes: Praise posts lean toward productivity “vibes” around speed and agentic workflows (e.g., @Bodok0 and @nomanyaqubNY), with one concrete data point of successful use on a 90k LOC production codebase (@oppatunist). Criticism is more evidence-oriented, citing observable issues like inconsistent subagent model reporting (@quiet_node, with CLI version and reproduction steps) or limited reliability for full codebases versus snippets (@Robbie_Render, tied to specific optimization tasks). Overall, positive takes emphasize iteration speed in controlled setups, while skeptical ones highlight trust gaps or bugs in agent tooling—both grounded in direct usage rather than benchmarks. No xAI/Venice promotional accounts included.

ELAPSED=48.43

Experienced developers (self-identified seniors/staff/SWE/execs/systems engineers with production or complex-codebase experience) in the past ~48 hours (roughly since 2026-07-11) frequently highlight Grok 4.5’s speed, context handling, token efficiency, and practical performance in Cursor/CLI/agent workflows for coding—especially implementation, prototyping, troubleshooting, and large codebases—while criticisms focus on reliability in agentic edits, instruction following, occasional errors/incoherence, and not fully matching top rivals (e.g., Fable/Claude variants) for complex or standards-heavy work without oversight.[1]

Posts exclude xAI/Venice/official promotional accounts. Representative sample spanning praise and criticism (timestamps in GMT; URLs constructed as standard https://x.com/username/status/ID):

1. Praise (Senior Software Engineer – productivity/speed for implementation) Author: Juan (@Bodok0), bio: Senior Software Engineer. Post: https://x.com/Bodok0/status/2076458803965432259 (Mon, 13 Jul 2026 ~00:08) Short quote: “Grok 4.5 is by far the best model to write code. It’s extremely fast inference do actually have a huge impact on productivity. Use Fable to write the roadmap and write the APIs ahead. Then grok implements it and use fable as advisor if anything goes wrong.” Context: Practical hybrid workflow endorsement from a senior engineer.

2. Praise (Tech exec / complex systems – Cursor troubleshooting & bottlenecks) Author: Rick Braddy (@RickGBraddy), bio: Veteran - Creator/Maker - Cryptographer - Tech Exec; building complex C/Go cloud apps. Post: https://x.com/RickGBraddy/status/2076463906109943953 (Mon, 13 Jul 2026 ~00:29; quotes his related earlier post) Short quote: “Grok 4.5 runs circles around all other Cursor models, especially for troubleshooting complex systems level software” (and earlier: crushed days of bottlenecks, deep context, faster than expensive models, DynamoDB + cache tuning flying, “game changer”). Context: Hands-on production-style complex systems work in Cursor.[1]

3. Praise (Production large codebase – performance & context) Author: Matthew Jackson (@oppatunist); uses it on real production work. Post: https://x.com/oppatunist/status/2076419399456616844 (Sun, 12 Jul 2026 ~21:32) Short quote: “I use Grok 4.5 on a production codebase of ~90k loc, and I have no retarded issues at all. Performance and token usage massively improved. It can read the entire codebase and get to work so quickly.” Context: Direct comparison of tables turning on a sizable real production codebase.[2]

4. Balanced / mild criticism (Rapid prototyping strength vs. instruction-following weakness) Author: Gen Z Mind (@gen_z_mind), bio: Read.Code. Debug. Write. Building with logic… Post: https://x.com/gen_z_mind/status/2075796996213112865 (Sat, 11 Jul 2026 ~04:19) Short quote: “One thing that impressed me about Grok 4.5 was its ability to build an application in a single shot. The app was functional, the architecture was reasonable… The tradeoff was instruction following. Even with explicit development guidelines, it ignored them… optimized for speed… If your priority is getting a working prototype as fast as possible, Grok 4.5 performs well. If your workflow depends on strict compliance with engineering standards… room for improvement.” Context: Concrete single-shot app build experience noting explicit tradeoffs (e.g., docstring/style compliance).[3]

5. Criticism (Systems Engineer – agentic reliability failures) Author: Gandalf Stormdrain (@auroter), bio: Systems Engineer. Ex Cline, Protocol Labs, Lazer, Sixense… Post: https://x.com/auroter/status/2076227257505648795 (Sun, 12 Jul 2026 ~08:48) Short quote: “Grok 4.5 is completely unusable for coding. I told it to make a simple change to my code. It broke the entire application… It did a git reset and clobbered all of my uncommitted work. It kept saying completely incoherent things… truncates words randomly… WTF is wrong with xAI?” Context: Detailed failure report on simple change + undo in a real codebase (git mishandling, incoherence, thinking-trace leakage); some replies noted this as outlier vs. widespread positive experiences.[4]

Additional notes from related posts (for span): Other seniors/SWE report shipping many PRs/UI fixes rapidly with the CLI, strong value/speed for daily implementation (sometimes paired with Fable/Claude for planning), better token efficiency than some score-implied rivals, and suitability for clear-spec/repetitive tasks or prototyping. Milder pushback includes “ain’t gonna act like Opus/Fable in coding,” syntax errors in early limited use, or good model but poor harness/tooling. One senior dev called it “still fucking stupid” (improved but untrusted for full codebases; fine for snippets like optimizations) and saw no job risk.[5]

Synthesis: Evidence vs. Vibes

Evidence-based signals (specific, reproducible, or measurable claims): Multiple developers report strong results on real/production-scale work (e.g., ~90k LOC with improved performance/token use and full-codebase reading; complex C/Go systems troubleshooting and cache tuning unblocked; 38 PRs of bugfixes/UI in one session; single-shot functional apps with reasonable architecture; faster iteration than slower high-end models for the same tasks; lower token use in agent indexes vs. Fable). Speed of inference is repeatedly cited as a concrete productivity multiplier. Some note competitive or edge results on certain software benchmarks (e.g., SWE-Atlas-QnA) alongside clear efficiency advantages, though it trails on others like DeepSWE or SWE-Bench Pro. Tooling bugs (CLI subagent model reporting, harness copy-paste/git issues) and occasional agentic failures (destructive git, app breakage on simple edits) are documented with specifics. Hybrid workflows (Grok for implementation + stronger model for planning/review) appear repeatedly as a practical pattern.

Vibes / subjective or low-evidence claims: Sweeping superlatives (“by far the best,” “phenomenal,” “runs circles,” “game changer,” “addictive,” “we’re cooked”) without metrics or side-by-side tests; broad dismissals (“completely unusable,” “still fucking stupid,” “brain-dead”) that may reflect isolated agent/tooling failures, prompt quality, or early access quirks rather than consistent model behavior; hype around cost/speed as decisive without quantifying error rates or long-horizon reliability; job-security reassurances or “tables have turned” excitement. Some negative experiences are contested in replies as outliers.

Overall picture from these developers: Grok 4.5 is seeing rapid adoption as a high-value, high-speed daily driver (especially in Cursor/CLI) for coding implementation, iteration, and large-context work among experienced users who value productivity and cost, often outperforming or matching pricier options on practical tasks. It is not universally viewed as fully reliable for unattended complex agentic coding or strict standards adherence—oversight, pairing with other models, and careful git/tooling practices are advised. Praise is denser and more specific on speed/efficiency/context; criticism is sharper on reliability edge cases and incomplete instruction following. Experiences vary by workflow (prototyping/implementation favors it; precision/long-horizon or standards-heavy may still prefer alternatives). This is a snapshot of recent chatter, not exhaustive benchmarks.

ELAPSED=53.11

Here are 5 substantive X posts from the past 7 days (roughly July 6–13, 2026) focused on PostgreSQL performance or internals. These emphasize original technical observations, benchmarks, patches/upcoming features, or implementation lessons. I excluded promotions, ads, generic tutorials, and low-substance content. Direct links use the standard https://x.com/user/status/ID format based on post IDs.

1. Ben Dicken (@BenjDicken) – July 12, 2026 URL: https://x.com/BenjDicken/status/2076303632799281253 Snippet: “Database performance and human efficiency are limited by the same thing: the universal scalability law. In a perfect world, throwing more cores at Postgres would scale performance linearly. Two problems: contention and coherency. Contention = some resources are shared across processes. Shared buffers. WAL. Synchronization and locking… Coherency = data in shared resources must be consistent! CPU cache flushing. IPC. Disk sync… This is one of N reasons why sharding a database becomes a necessary scaling axis…” Why worth reading: Deep, original analogy applying the universal scalability law (contention + coherency) directly to Postgres shared resources like buffers and WAL. Explains real limits on scaling cores and why sharding matters—valuable for anyone tuning high-QPS systems. High engagement (71+ likes) and thoughtful replies.

2. alex shapalov (@alxshp) – July 8, 2026 URL: https://x.com/alxshp/status/2074992935662432407 Snippet: “PostgreSQL 19 performance work looks seriously interesting. → Parallel autovacuum → Dynamic async I/O workers → REPACK CONCURRENTLY → Better anti-joins → Broader incremental sort → Eager aggregation → Up to 2x faster inserts with foreign-key checks → Async I/O stats in EXPLAIN. This is the kind of release operators feel. Less waiting. Less blocking. Better visibility. More control.” Why worth reading: Concise, high-signal summary of upcoming PG19 performance patches and features with direct operator impact (vacuum parallelism, async I/O, etc.). Focuses on practical gains rather than hype; excellent for planning upgrades or anticipating internals improvements.

3. Agasta (@idkAgasta) – July 11, 2026 URL: https://x.com/idkAgasta/status/2075997096000573490 Snippet: “One of the coolest things I’ve learned during GSoC has been PostgreSQL internals. We recently implemented a lazy migration strategy that added a new column to 22 million rows without locking up the production database. Wrote about how it works (and why this approach was much better than a table rewrite).” Why worth reading: Real-world GSoC implementation lesson on Postgres internals for zero-downtime schema changes on large tables (22M rows). Highlights lazy migration vs. traditional rewrite trade-offs—practical for DBAs facing similar production constraints.

4. Mahmoud Tantawy (@mtantawy) – July 12, 2026 URL: https://x.com/mtantawy/status/2076312296050078039 Snippet: (In Arabic, translated context) Comparing Postgres vs. ClickHouse on specific queries; built a benchmark tool, iterated with AI review after initial results, and refined the methodology and outcomes. Why worth reading: Hands-on benchmark work involving custom tooling, query analysis, and iterative validation between Postgres and ClickHouse. Shows original technical process and lessons from real comparison rather than vendor claims.

5. DALIBO (@dalibo) – July 10, 2026 URL: https://x.com/dalibo/status/2075497176260579382 Snippet: “TECH : la performance des requêtes, c’est le dada d’Alain ! Pour vous aider à les améliorer, il en vous propose de découvrir le paramètre default_statistics_target => https://blog.dalibo.com/2026/07/10/statistics-target.html” (with image of the parameter in context). Why worth reading: Focused technical deep-dive from Postgres experts on default_statistics_target and its direct effect on query planner statistics and performance. Backed by their blog post; substantive internals/practical tuning insight without being generic.

These posts were surfaced via targeted keyword and semantic searches prioritizing recency, engagement signals, and technical depth. Timestamps and content are as posted.

ELAPSED=30.68 USAGE={“cache_read_input_tokens”: 11200, “completion_tokens”: 2145, “completion_tokens_details”: {“reasoning_tokens”: 1188}, “prompt_tokens”: 20672, “prompt_tokens_details”: {“cached_tokens”: 11200}, “total_tokens”: 22817}

Here are 5 substantive X posts from July 6–13, 2026 (within the past 7 days as of July 13), focused on PostgreSQL performance or internals. I prioritized original technical observations, benchmarks/claims, architectural details, or real-world incident lessons over generic advice, checklists, job posts, or promotions. Each includes the direct URL, a quoted snippet, approximate date (from post metadata), and rationale.[1][2]

1. Ben Dicken (@BenjDicken) – Original analysis of Postgres scaling limits via the universal scalability law. URL: https://x.com/BenjDicken/status/2076303632799281253 Date: July 12, 2026 (Sun, ~13:52 GMT) Quoted snippet: “Database performance and human efficiency are limited by the same thing: the universal scalability law. In a perfect world, throwing more cores at Postgres would scale performance linearly. Two problems: contention and coherency. Contention = some resources are shared across processes. Shared buffers. WAL. Synchronization and locking are required here, diminishing returns with scale. Coherency = data in shared resources must be consistent! CPU cache flushing. IPC. Disk sync. …” Why worth reading: Deep, original breakdown of Postgres internals (shared buffers, WAL, locking) explaining why linear multi-core scaling fails in practice, with a novel parallel to organizational efficiency. Includes a diagram for clarity.[1]

2. Abhishek Singh (@0xlelouch_) – Real-world production incident lesson on schema migration locking and recovery. URL: https://x.com/0xlelouch_/status/2075739326097281358 Date: July 11, 2026 (Sat) Quoted snippet: “Senior engineer prod scenario: A Postgres migration hits production and takes an ACCESS EXCLUSIVE lock on a hot table. p95 jumps from 30ms to 8s, write queue grows, on-call is staring at pg_stat_activity. What do you do in the next 10 minutes to recover safely? Do you kill the migration, cancel the lock, or fail over? How do you confirm data correctness after? Now prevention: how do you design the next migration so it’s idempotent and observable? Lock timeout vs statement timeout, CONCURRENTLY, backfill in batches, expand/contract, feature flags, rollback plan…” Why worth reading: Concrete incident narrative + actionable prevention strategies drawn from Postgres locking/MVCC behavior and operational realities. Rare, high-value lesson on performance degradation and safe schema changes.[2]

3. Agasta (@idkAgasta) – GSoC-derived technical details on a lazy (non-locking) column addition migration for a large table. URL: https://x.com/idkAgasta/status/2075997096000573490 Date: July 11, 2026 (Sat, ~17:34 GMT) Quoted snippet: “One of the coolest things I’ve learned during GSoC has been PostgreSQL internals. We recently implemented a lazy migration strategy that added a new column to 22 million rows without locking up the production database. Wrote about how it works (and why this approach was much better than a table rewrite).” (Includes image of related content.) Why worth reading: First-hand account of leveraging Postgres internals for a production schema change on 22M rows, avoiding locks/downtime. Focuses on the implementation rationale and comparison to traditional rewrites.[3]

4. self.dll (@seelffff) – Detailed discussion of the pgrust project (full Postgres reimplementation in Rust with AI assistance), including compatibility, architecture, and performance claims. URL: https://x.com/seelffff/status/2076000975295267274 Date: July 11, 2026 (Sat, ~17:49 GMT) Quoted snippet: “SOMEONE IS REWRITING POSTGRES IN RUST WITH AI AND IT ALREADY MATCHES 46,000 OF POSTGRES’S OWN TESTS ★ 1.9k, agpl-3.0, there’s a webassembly demo you can poke in the browser not a toy port. pgrust boots from a real postgres 18.3 data directory and matches postgres output across 46,000+ regression queries the method is the story: rust + ai-assisted programming, keeping postgres’s own test suite as the oracle. … what the author says is coming (not shipped yet, so treat as a claim): → a new version passing 100% of the regression suite → thread-per-connection instead of process-per-connection → 50% faster than postgres on transactions → ~300x faster on analytical queries (2x off clickhouse, closing) it’s not production-ready and they say so.” (Includes video.) Why worth reading: Substantive coverage of a major internals project—compatibility testing, disk compatibility, model shift (thread vs. process), and claimed benchmarks. Highlights AI-assisted development of a complex system while noting caveats.[4]

5. Ryan Robitaille (@ryrobes) – Custom architecture for scaling OLAP reads off a single Postgres master with learned query routing. URL: https://x.com/ryrobes/status/2075784486323622162 Date: July 11, 2026 (Sat, ~03:29 GMT) Quoted snippet: “Single Postgres master - fanned out OLAP reads on stateless (and serverless / Cloud Run) query nodes (w optional GQE GPU accel), that choose from 9 diff exec engines based on learned latency - with ‘boring’ heap fallback. ‘Always correct. Usually fast.’” (Includes diagram/image.) Why worth reading: Original technical description of a performance-oriented query fan-out system using multiple execution engines selected by learned latency models on top of Postgres. Practical insight into hybrid transactional/analytical scaling.[5]

These posts stand out for their depth, originality, and direct relevance to Postgres internals or performance challenges. Additional context (e.g., related discussions on the Rust rewrite) appears in surrounding threads, but the selected posts are self-contained and substantive.

ELAPSED=78.01 USAGE={“cache_read_input_tokens”: 11904, “completion_tokens”: 5725, “completion_tokens_details”: {“reasoning_tokens”: 4356}, “prompt_tokens”: 26041, “prompt_tokens_details”: {“cached_tokens”: 11904}, “total_tokens”: 31766}

Here are 5 substantive X (Twitter) posts from roughly the past 7 days (approx. July 6–13, 2026, based on tool results) about PostgreSQL performance or internals. I prioritized original technical observations, practical tips with reasoning, benchmarks/lessons, and explanations of mechanisms over tutorials, jobs, or pure promotion. Direct URLs use the format https://x.com/username/status/ID. Snippets are quoted from the posts; dates are from timestamps.[1][2]

1. Ben Dicken (@BenjDicken) – Universal Scalability Law applied to Postgres URL: https://x.com/BenjDicken/status/2076303632799281253 Date: Sun, 12 Jul 2026 Snippet: “Database performance and human efficiency are limited by the same thing: the universal scalability law. In a perfect world, throwing more cores at Postgres would scale performance linearly. Two problems: contention and coherency. Contention = some resources are shared across processes. Shared buffers. WAL. Synchronization and locking are required here, diminishing returns with scale. Coherency = data in shared resources must be consistent! CPU cache flushing. IPC. Disk sync. … This is one of N reasons why sharding a database becomes a necessary scaling axis…” Why worth reading: Clear, original linkage of USL concepts (contention on shared_buffers/WAL/locks + coherency costs) to real Postgres scaling limits, with a diagram reference. Strong technical insight into why vertical scaling plateaus and when sharding becomes necessary—not generic advice.[3]

2. Joe Sluis (@jyobo10) – Avoiding indefinite waits on row locks URL: https://x.com/jyobo10/status/2076412359955071075 Date: Sun, 12 Jul 2026 Snippet: “Two interesting ways to avoid getting stuck waiting on locked rows in Postgres: 1) FOR UPDATE NOWAIT - Instead of blocking and waiting for a lock, this will immediately throw an error if the rows are locked by another transaction … 2) SET lock_timeout = ‘3s’ - if a statement ends up waiting on any lock for longer than the specified duration, then Postgres cancels it with an error rather than letting it wait either of these can be helpful when you’d rather a transaction fail fast than have a query wait indefinitely for a row lock” Why worth reading: Concise, practical internals tip with code-level options (NOWAIT vs. session-level timeout) and clear use-case reasoning for fail-fast designs under contention. Includes image of usage; useful for real production locking issues.[4]

3. PsudoMike (@PsudoMike) – Partial indexes for size/write performance URL: https://x.com/PsudoMike/status/2076339037128786276 Date: Sun, 12 Jul 2026 Snippet: “Most people don’t know this about Postgres indexes. You don’t need to index the whole column. CREATE INDEX idx_active_orders ON orders (created_at) WHERE status = ‘active’; Smaller index. Faster writes. Same query speed for the rows you actually care about.” Why worth reading: Original emphasis on a frequently underused feature (partial indexes) with direct performance implications (smaller size → less I/O/write overhead while preserving query speed for filtered workloads). Practical and observation-driven rather than a basic tutorial. (Related posts by the same author expand on selectivity checks.)[2]

4. Percona Community (@PerconaBytes) – Autovacuum internals benchmark findings URL: https://x.com/PerconaBytes/status/2075497258481532941 Date: Fri, 10 Jul 2026 Snippet: “Same dead-tuple count, 8.7x difference in autovacuum runtime. 360 benchmark runs on PG18 show the real cost driver is dirty pages, not dead tuples, and each redundant index adds a near-constant chunk of time. [link to blog]” Why worth reading: Substantive benchmark-driven insight (hundreds of runs) into autovacuum cost drivers on PG18—dirty pages dominate over dead tuples, plus constant overhead per redundant index. Moves beyond “vacuum more” to measurable internals lessons on what actually slows vacuum. (Links to detailed write-up; not pure marketing.)[5]

5. Abhishek Singh (@0xlelouch_) – Top 10 common Postgres mistakes (performance/ops focus) URL: https://x.com/0xlelouch_/status/2074027994427850913 Date: Mon, 06 Jul 2026 Snippet: “Top 10 PostgreSQL mistakes I keep seeing: 1) SELECT * in hot paths… 2) Missing composite indexes (and wrong column order)… 3) No EXPLAIN (ANALYZE, BUFFERS)… 5) No connection pooling (pgBouncer)… 7) Not using timeouts (statement_timeout, lock_timeout)… 8) Ignoring autovacuum; bloat + dead tuples + surprise latency spikes 9) Long transactions; holding locks, blocking vacuum, amplifying contention 10) Weak observability; no pg_stat_statements…” Why worth reading: Distilled lessons from real incidents/observations covering query, indexing, locking/timeouts, vacuum/bloat, pooling, and observability pitfalls that directly cause performance collapses. Actionable and grounded in production patterns rather than theory.[6]

These focus on original technical value (scaling limits, lock handling, index design, vacuum costs, common failure modes). Engagement varies; some are lower-volume but high-signal. For more context (images, replies, or linked blogs), open the URLs. If you need older posts, deeper threads, or a different angle (e.g., more on WAL/replication), let me know!

ELAPSED=29.10 USAGE={“cache_read_input_tokens”: 77440, “completion_tokens”: 2994, “completion_tokens_details”: {“reasoning_tokens”: 1658}, “prompt_tokens”: 100241, “prompt_tokens_details”: {“cached_tokens”: 77440}, “total_tokens”: 103235}

Here are 5 substantive recent X (Twitter) posts from roughly the past 7 days (based on data around July 5–12, 2026) focused on PostgreSQL performance or internals. I prioritized original technical observations, benchmarks/insights, patches/features, or incident-style lessons; excluded job ads, generic tutorials, pure vendor marketing, and low-substance content. Dates use the post timestamps (GMT). Direct URLs are provided as https://x.com/username/status/ID.[1][2]

1. Ben Dicken (@BenjDicken) on the Universal Scalability Law applied to Postgres

URL: https://x.com/BenjDicken/status/2076303632799281253 Date: Sun, 12 Jul 2026 Quoted snippet: “In a perfect world, throwing more cores at Postgres would scale performance linearly. Two problems: contention and coherency. Contention = some resources are shared across processes. Shared buffers. WAL. Synchronization and locking are required here, diminishing returns with scale. Coherency = data in shared resources must be consistent! CPU cache flushing. IPC. Disk sync. … This is one of N reasons why sharding a database becomes a necessary scaling axis…” Why worth reading: Clear, original technical framing of multi-core/shared-resource limits in Postgres (buffers, WAL, locking, coherency costs). Links the same principles to why teams/orgs also lose efficiency at scale; high-signal for performance architecture thinking. Includes a diagram reference.[1][2]

2. Franck Pachot (@FranckPachot) on unique indexes and heap visibility (internals via pageinspect)

URL: https://x.com/FranckPachot/status/2075262204090122728 Date: Thu, 09 Jul 2026 Quoted snippet: “🐘 Do you think unique indexes have unique keys? Not in PostgreSQL. 🤓 Let’s PageInspect heap and index tuples in a new blog post: [link to deep dive]” Why worth reading: Pure Postgres internals insight—uniqueness is resolved via heap tuple visibility (MVCC), not solely by the index keys. Encourages hands-on use of pageinspect on heap/index tuples. Excellent for understanding how uniqueness actually works under the hood (with a linked blog post for details).[3][4]

3. Agasta (@idkAgasta) on a lazy migration adding a column to 22M rows without locking

URL: https://x.com/idkAgasta/status/2075997096000573490 Date: Sat, 11 Jul 2026 Quoted snippet: “One of the coolest things I’ve learned during GSoC has been PostgreSQL internals. We recently implemented a lazy migration strategy that added a new column to 22 million rows without locking up the production database. Wrote about how it works (and why this approach was much better than a table rewrite)” (links to Medium write-up). Why worth reading: First-hand technical observation and practical lesson from real work (GSoC) on zero/low-lock schema changes for large tables. Contrasts with full table rewrite approaches; valuable for anyone dealing with production migrations and Postgres storage/locking internals.[5][6]

4. alex shapalov (@alxshp) on PostgreSQL 19 performance work and patches

URL: https://x.com/alxshp/status/2074992935662432407 Date: Wed, 08 Jul 2026 Quoted snippet: “PostgreSQL 19 performance work looks seriously interesting. → Parallel autovacuum → Dynamic async I/O workers → REPACK CONCURRENTLY → Better anti-joins → Broader incremental sort → Eager aggregation → Up to 2x faster inserts with foreign-key checks → Async I/O stats in EXPLAIN … This is the kind of release operators feel. Less waiting. Less blocking. Better visibility. More control.” Why worth reading: Concise, operator-focused summary of concrete performance-oriented changes and patches in the upcoming release (I/O, vacuum, sorting/joins, inserts, observability). Highlights improvements that address real production pain points around blocking and visibility.[7][7][8]

5. Abhishek Singh (@0xlelouch_) on a production migration locking incident and recovery/prevention

URL: https://x.com/0xlelouch_/status/2075739326097281358 Date: Sat, 11 Jul 2026 Quoted snippet: “Senior engineer prod scenario: A Postgres migration hits production and takes an ACCESS EXCLUSIVE lock on a hot table. p95 jumps from 30ms to 8s, queue queue grows, on-call is staring at pg_stat_activity. What do you do in the next 10 minutes to recover safely? Do you kill the migration, cancel the lock, or fail over? How do you confirm data correctness after? Now prevention: how do you design the next migration so it’s idempotent and observable? Lock timeout vs statement timeout, CONCURRENTLY, backfill in batches, expand/contract…” Why worth reading: Realistic incident-style lesson on ACCESS EXCLUSIVE locks during migrations, queueing effects on p95 latency, safe recovery (e.g., cancel vs failover), correctness checks, and prevention patterns (timeouts, CONCURRENTLY, expand/contract, observability). Sparks practical discussion; strong ops/internals value. (Replies in the thread add further details.)[9][10]

These were surfaced via keyword/semantic searches filtered for recency, technical keywords (performance, vacuum, WAL, EXPLAIN, locks, indexes, patches, etc.), and engagement/substance signals. Engagement varies (some are high-signal even if not mega-viral). For deeper context on any, check the linked blogs or threads. Note that X search recency can have minor indexing lag, and exact “past 7 days” depends on the precise current time.

ELAPSED=53.33 USAGE={“cache_read_input_tokens”: 256256, “completion_tokens”: 5688, “completion_tokens_details”: {“reasoning_tokens”: 4268}, “prompt_tokens”: 289927, “prompt_tokens_details”: {“cached_tokens”: 256256}, “total_tokens”: 295615}