Code quality and verification
Testing, code review, simplicity, architecture, maintainability, runtime evidence, and validating agent-generated changes.
44%
Best tweets about Coding
50 Best Tweets About Coding (2026)
A curated collection of the sharpest, most-shared X posts about coding—saved so you do not have to dig through the timeline yourself. Updated weekly.
Developers on the bugs, the tools, and the takes that get the whole timeline arguing.
- Creators
- 45
- Updated
Original Xholic analysis
What 50 top Coding posts reveal
The supplied posts frame AI coding as a debate over autonomy and oversight: some describe agents completing substantial tasks, while others emphasize context, tests, review, and code comprehension when software is intended to ship.
- Dominant tone
- Positive
- Median score
- 39.9
- Leading format
- Opinion
- Recent posts
- 24%
52% of posts
All-time engagement
38% of posts
Published in 90 days
Conversation map
The themes creators return to
AI agent workflows
Coding agents as autonomous or parallel workers for planning, implementing, debugging, testing, reviewing, and shipping software.
38%
AI coding productivity
Claims and evidence about speed, ROI, task completion, automation, and whether agents make developers faster or slower.
34%
Changing developer role
How AI shifts engineering toward judgment, system design, product thinking, orchestration, and oversight.
34%
Vibe coding debate
Arguments over hands-off AI development versus supervised AI-assisted coding, especially for production work.
26%
Agent context and instructions
CLAUDE.md, skills, memory, hooks, plugins, prompts, specs, and guardrails that make coding agents more reliable.
24%
Developer skills and fundamentals
The continuing value of reading code, understanding underlying systems, learning core tools, and junior developer development.
18%
AI coding security risk
Security failures, exposed secrets, vulnerable AI-generated apps, adversarial testing, and supply-chain concerns.
8%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 98
- Median reposts
- 10
- Median replies
- 14
- Median views
- 7.3K
Posts with media make up 56% of this collection. Their median all-time score is 52.6, compared with 31.7 for text-only posts.
Format mix
- Opinion 38% · score 24.2
- Announcement 18% · score 23.7
- List 14% · score 40.5
- Tutorial 12% · score 89.9
Consensus and debate
Where creators agree, and where they do not
Shared view
Verification is a recurring control
Several posts recommend tests, explicit success criteria, diff review, and runtime evidence as ways to evaluate AI-assisted changes. These are presented as workflow practices and opinions within the conversation, not as independently established guarantees.
Shared view
Context and planning are common recommendations
Posts advocate durable instructions, scoped context, and planning before edits rather than relying on a single prompt. One post lists production-agent patterns including persistent instructions, scoped context, and an explore-plan-act sequence.
Shared view
Some voices emphasize judgment beyond implementation
Several posts argue that requirements, architecture, task decomposition, review, and product judgment remain important as agents take on more implementation work. This is a recurring viewpoint, rather than a measured shift in developer roles.
Open debate
Hands-off vibe coding versus supervised delivery
Posts differ on the value and limits of vibe coding. One celebrates its accessibility and creative potential, while others recommend planning, constraining, and inspecting agent output—particularly for work described as production software.
Open debate
Can outcome tests replace reading code?
One post argues for shifting verification toward acceptance tests and observed product behavior. Other posts argue that code inspection, verifiable systems, and code-reading skills remain necessary. These are competing perspectives expressed in the supplied posts.
Open debate
Productivity claims receive pushback
The set includes first-person accounts of substantial agent-assisted work alongside posts that cite or describe studies and observations questioning productivity gains in complex or production-oriented work. The cited study claims are reported by the posts themselves.
What performs
Patterns behind standout posts
A security-themed narrative leads the supplied outliers
Tweet 2039077799643005198 is the highest supplied outlier, with an all-time score of 14,874.26—372.51× the supplied median all-time score of 39.93. Its text is a source-code-leak narrative.
Tutorials have a higher supplied median than the overall benchmark
Tutorials have a supplied median all-time score of 89.93, compared with the overall supplied median of 39.93. The CLAUDE.md workflow post is also listed as an outlier at 3,467.73.
Quality and instruction themes rank highly by supplied theme median
The supplied median all-time score is 79.56 for Code quality and verification and 77.37 for Agent context and instructions. These are descriptive theme-level results, not evidence that either topic causes higher performance.
Media posts have the higher supplied median
Media posts have a supplied median all-time score of 52.59, versus 31.66 for text-only posts. Media appears in 28 of the 50 tweets.
Statistical standouts
- View standout post 1 Score 14874.3 · 372.51× median
- View standout post 2 Score 5803.3 · 145.34× median
- View standout post 3 Score 3467.7 · 86.85× median
- View standout post 4 Score 810.2 · 20.29× median
- View standout post 5 Score 691.2 · 17.31× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Guri Singh
@heygurisingh
2 posts
-
2. Daniel Lemire
@lemire
2 posts
-
3. Dr Milan Milanović
@milan_milanovic
2 posts
-
4. George from 🕹prodmgmt.world
@nurijanian
2 posts
-
5. smrati tiwari
@smratitiwa86867
2 posts
-
6. Akshay 🚀
@akshay_pachaar
1 post
Guri Singh’s two included posts center supervised agent use
Guri Singh’s two supplied evidence tweets describe field-study claims and argue against hands-off production use. Supplied creator analytics list a median all-time score of 348.95 across the two tweets.
Milan Milanović pairs a study summary with a Stack Overflow reflection
Milan Milanović’s included posts comprise a detailed summary of debugging-study claims and a reflection on Stack Overflow’s relationship to AI training. Supplied analytics list a 349.64 median all-time score across two tweets.
Lemire’s included posts stress context and code comprehension
Daniel Lemire’s two evidence tweets discuss context-dependent engineering decisions and argue that reading and writing code remain part of developing deep technical understanding. Supplied analytics list a 68.65 median all-time score across two tweets.
Since the previous snapshot
What changed since Aug 17, 2026
- 60% of the selected posts remained.
- The creator count changed by +3.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best Coding tweets
Top Coding tweets from 45 creators
Ranked 01–50
- 01
@Jeremybtc ·
Anthropic accidentally leaked their entire source code yesterday. What happened next is one of the most insane stories in tech history. > Anthropic pushed a software update for Claude Code at 4AM. > A debugging file was accidentally bundled inside it. > That file contained 512,000 lines of their proprietary source code. > A researcher named Chaofan Shou spotted it within minutes and posted the download link on X. > 21 million people have seen the thread. > The entire codebase was downloaded, copied and mirrored across GitHub before Anthropic's team had even woken up. > Anthropic pulled the package and started firing DMCA takedowns at every repo hosting it. > That's when a Korean developer named Sigrid Jin woke up at 4AM to his phone blowing up. > He is the most active Claude Code user in the world with the Wall Street Journal reporting he personally used 25 billion tokens last year. > His girlfriend was worried he'd get sued just for having the code on his machine. > So he did what any engineer would do. > He rewrote the entire thing in Python from scratch before sunrise. > Called it claw-code and Pushed it to GitHub. > A Python rewrite is a new creative work. DMCA can't touch it. > The repo hit 30,000 stars faster than any repository in GitHub history. > He wasn't satisfied. He started rewriting it again in Rust. > It now has 49,000 stars and 56,000 forks. > Someone mirrored the original to a decentralised platform with one message, "will never be taken down." > The code is now permanent. Anthropic cannot get it back. Anthropic built a system called Undercover Mode specifically to stop Claude from leaking internal secrets. Then they leaked their own source code themselves. You cannot make this up.
- 02
@karpathy ·
It is hard to communicate how much programming has changed due to AI in the last 2 months: not gradually and over time in the "progress as usual" way, but specifically this last December. There are a number of asterisks but imo coding agents basically didn’t work before December and basically work since - the models have significantly higher quality, long-term coherence and tenacity and they can power through large and long tasks, well past enough that it is extremely disruptive to the default programming workflow. Just to give an example, over the weekend I was building a local video analysis dashboard for the cameras of my home so I wrote: “Here is the local IP and username/password of my DGX Spark. Log in, set up ssh keys, set up vLLM, download and bench Qwen3-VL, set up a server endpoint to inference videos, a basic web ui dashboard, test everything, set it up with systemd, record memory notes for yourself and write up a markdown report for me”. The agent went off for ~30 minutes, ran into multiple issues, researched solutions online, resolved them one by one, wrote the code, tested it, debugged it, set up the services, and came back with the report and it was just done. I didn’t touch anything. All of this could easily have been a weekend project just 3 months ago but today it’s something you kick off and forget about for 30 minutes. As a result, programming is becoming unrecognizable. You’re not typing computer code into an editor like the way things were since computers were invented, that era is over. You're spinning up AI agents, giving them tasks *in English* and managing and reviewing their work in parallel. The biggest prize is in figuring out how you can keep ascending the layers of abstraction to set up long-running orchestrator Claws with all of the right tools, memory and instructions that productively manage multiple parallel Code instances for you. The leverage achievable via top tier "agentic engineering" feels very high right now. It’s not perfect, it needs high-level direction, judgement, taste, oversight, iteration and hints and ideas. It works a lot better in some scenarios than others (e.g. especially for tasks that are well-specified and where you can verify/test functionality). The key is to build intuition to decompose the task just right to hand off the parts that work and help out around the edges. But imo, this is nowhere near "business as usual" time in software.
- 03
@techNmak ·
Andrej Karpathy wrote something that every Claude Code user has felt but couldn't articulate. Three quotes. Read them slowly. "The models make wrong assumptions on your behalf and just run along with them without checking. They don't manage their confusion, don't seek clarifications, don't surface inconsistencies, don't present tradeoffs, don't push back when they should." "They really like to overcomplicate code and APIs, bloat abstractions, don't clean up dead code... implement a bloated construction over 1000 lines when 100 would do." "They still sometimes change/remove comments and code they don't sufficiently understand as side effects, even if orthogonal to the task." You've seen all three. Probably this week. Someone turned these three observations into a single CLAUDE[.]md file. Four principles, one install, directly addresses each quote: 1./ Think before coding Don't assume. Don't hide confusion. State ambiguity explicitly. Present multiple interpretations rather than silently picking one. Push back if a simpler approach exists. Stop and ask rather than guess. 2./ Simplicity first No features beyond what was asked. No abstractions for single-use code. No "flexibility" that wasn't requested. No error handling for impossible scenarios. The test: would a senior engineer say this is overcomplicated? If yes, rewrite it. 3./ Surgical changes Don't "improve" adjacent code. Don't refactor things that aren't broken. Match the existing style even if you'd do it differently. If you notice unrelated dead code, mention it, don't delete it. Every changed line should trace directly to the request. 4./ Goal-driven execution Transform "fix the bug" into "write a test that reproduces it, then make it pass." Transform "add validation" into "write tests for invalid inputs, then make them pass." Give it success criteria and watch it loop until done. This last one is Karpathy's key insight captured directly: "LLMs are exceptionally good at looping until they meet specific goals... Don't tell it what to do, give it success criteria and watch it go." It's a single file. Drop it into any project.
- 04
@johncrickett ·
The best AI coding content isn't on your feed. It's buried in conference talks nobody's sharing. I've been collecting them for months. These are the ones that rewired how I think about agents, context, and shipping code with AI. AI-Assisted Coding: 12-Factor Agents: Patterns of reliable LLM applications, Dex Horthy (HumanLayer) - https://t.co/XrZIr7z7Pu Making Codebases Agent Ready, Eno Reyes (Factory AI) - https://t.co/719HXk1yJQ To the moon! Navigating deep context in legacy code with Augment Agent, Forrest Brazeal & Matt Ball - https://t.co/CS12SUtkvk How Coding Agents change Software Development Forever, Hailong Zhang - https://t.co/roU2CZ3Bpb Collaborating with Agents in your Software Dev Workflow, Jon Peck & Christopher Harrison (Microsoft) - https://t.co/oM8fMO8fmk Productivity & ROI: Can you prove AI ROI in Software Eng? (Stanford 120k Devs Study), Yegor Denisov-Blanch - https://t.co/vj627ZTfkj Your AI Agent Isn't an Engineer: The Art of Thoughtful Anthropomorphism, Rizel Scarlett - https://t.co/eYDYrZf2V4 Context Engineering: Vibes won't cut it, Chris Kelly (Augment Code) - https://t.co/Z0N2h91VYc The Model Isn't Wrong, You're Just Bad at Prompting - https://t.co/2dvFLuV352 Context Platform Engineering to Reduce Token Anxiety, Val Bercovici (WEKA) - https://t.co/WiFC4iWut8 Prompt Engineering: Building with Anthropic Claude: Prompt Workshop, Zack Witten - https://t.co/eVhGxXMsU3 Spec-Driven Development: The New Code, Sean Grove (OpenAI) - https://t.co/gia14d1GNv Skills: Don't Build Agents, Build Skills Instead, Barry Zhang & Mahesh Murag (Anthropic) - https://t.co/6oJJdi1PjF Vibe Coding: How to Improve your Vibe Coding, Ian Butler - https://t.co/rC6pPt6iUD From Vibe Coding To Vibe Engineering, Kitze (Sizzy) - https://t.co/ozM5mtVKd5 2026: The Year The IDE Died, Steve Yegge & Gene Kim - https://t.co/keUBquYawD Vibe Coding with Confidence, Itamar Friedman (Qodo) - https://t.co/8s8klS3CO3 Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments, Harald Kirshner - https://t.co/84Q6nzTQPA Tool-Specific: Amp Code: Next Generation AI Coding, Beyang Liu (Amp Code) - https://t.co/KM5Hak1FEp How Claude Code Works, Jared Zoneraich - https://t.co/dE7kDcSBXB GitHub Copilot: The World's Most Widely Adopted AI Developer Tool, Dave Burnison - https://t.co/y2mCVoMO9Y Did I miss any great talks? Here’s my full list: https://t.co/qWgo8FaGzu
- 05
@milan_milanovic ·
𝗟𝗟𝗠𝘀 𝗔𝗿𝗲 𝗡𝗼𝘁 𝗥𝗲𝗮𝗱𝗶𝗻𝗴 𝗬𝗼𝘂𝗿 𝗖𝗼𝗱𝗲 We keep calling LLMs "AI coding assistants." But writing code and understanding code are not the same thing. Researchers from Virginia Tech and Carnegie Mellon University just ran 750,000 debugging experiments across 10 models to determine how well LLMs actually understand code. The results show that you should not blindly trust your AI coding assistant when debugging. Here is what they found: 𝟭. 𝗔 𝗿𝗲𝗻𝗮𝗺𝗲𝗱 𝘃𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗯𝗿𝗲𝗮𝗸𝘀 𝘁𝗵𝗲 𝗱𝗲𝗯𝘂𝗴𝗴𝗲𝗿 Researchers created a bug, confirmed that the LLM found it, then made changes that don't touch the bug at all, such as renaming a variable or adding a comment. In 78% of cases, the model could no longer find the same bug. The bug was still there. The variable names and comments changed, and that was enough. 𝟮. 𝗗𝗲𝗮𝗱 𝗰𝗼𝗱𝗲 𝗶𝘀 𝗮 𝘁𝗿𝗮𝗽 Adding code that never runs reduced bug-detection accuracy to 20.38%. Models treated dead code as live, and flagged it as the source of the bug. But the bug was in another line. So, LLMs cannot reliably distinguish "this runs" from "this never runs." 𝟯. 𝗠𝗼𝗱𝗲𝗹𝘀 𝗿𝗲𝗮𝗱 𝘁𝗼𝗽-𝘁𝗼-𝗯𝗼𝘁𝘁𝗼𝗺, 𝗻𝗼𝘁 𝗹𝗼𝗴𝗶𝗰𝗮𝗹𝗹𝘆 56% of correctly found bugs were in the first quarter of the file. Only 6% were in the last quarter. The further down the code, the less attention the model pays to it. If the bug lives in the bottom half of your file, the model is already less likely to find it. 𝟰. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻 𝗿𝗲𝗼𝗿𝗱𝗲𝗿𝗶𝗻𝗴 𝗮𝗹𝗼𝗻𝗲 𝗰𝘂𝘁 𝗮𝗰𝗰𝘂𝗿𝗮𝗰𝘆 𝗯𝘆 𝟴𝟯% Changing the order of functions in a Java file caused an 83% drop in debugging accuracy. The code still remained the same. Where the code physically sits in the file matters more to the model than what the code does. So, obviously, this is a sign of pattern recognition, not real code understanding. 𝟱. 𝗡𝗲𝘄𝗲𝗿 𝗺𝗼𝗱𝗲𝗹𝘀 𝗵𝗮𝗿𝗱𝗹𝘆 𝗺𝗼𝘃𝗲 𝘁𝗵𝗲 𝗻𝗲𝗲𝗱𝗹𝗲 Claude improved ~1% between 3.7 and 4.5 Sonnet on this task. Gemini improved by ~1.8%. Every model release comes with a new benchmark leaderboard and new headlines. But the ability to reason about code under realistic conditions is improving slowly. 𝟲. 𝗧𝗵𝗲𝘀𝗲 𝘄𝗲𝗿𝗲 𝗯𝗲𝘀𝘁-𝗰𝗮𝘀𝗲 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝘀 The study used single-file programs with ~250 lines, and each had a clear description of what the code should do. The authors say this was intentional. They wanted the best-case conditions. Real production code is multi-file, cross-module, and poorly documented. It will perform worse for sure. Here are three things worth changing based on the research: 🔹 𝗣𝗮𝘀𝘀 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗰𝗼𝗻𝘁𝗲𝘅𝘁, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗰𝗼𝗱𝗲. When asking an LLM to debug, include test output, stack traces, and failure messages alongside the source. Without runtime details, the model is guessing based on the code. 🔹 𝗗𝗼𝗻'𝘁 𝘁𝗿𝘂𝘀𝘁 𝗶𝘁 𝗼𝗻 𝗱𝗲𝗲𝗽-𝗳𝗶𝗹𝗲 𝗯𝘂𝗴𝘀. If the suspect code is in the bottom third of a long file, the model will have trouble finding it. Consider splitting the context or feeding the relevant function directly. 🔹 𝗖𝗹𝗲𝗮𝗻 𝘂𝗽 𝗱𝗲𝗮𝗱 𝗰𝗼𝗱𝗲 𝗯𝗲𝗳𝗼𝗿𝗲 𝘂𝘀𝗶𝗻𝗴 𝗔𝗜 𝗱𝗲𝗯𝘂𝗴𝗴𝗶𝗻𝗴 𝘁𝗼𝗼𝗹𝘀. Commented-out blocks and unreachable branches will mislead the model. It cannot filter them out. We rate AI coding tools on HumanEval. That tests whether a model can write a function from a description, but this says nothing about finding a bug in code it didn't write. Those are different problems. We're using the wrong benchmark.
- 06
@heygurisingh ·
Vibe coders are not going to like this. UC San Diego just published the first real field study of experienced developers using AI agents. They watched 13 of them code in the wild and surveyed 99 more. Zero of them vibe coded. Not one developer "fully gave in to the vibes." Not one trusted the agent to ship. The researchers found the opposite of what every Cursor demo on your timeline implies. Experienced devs plan before they prompt. They load the agent with heavy context. They verify every diff and refuse to merge code they haven't actually read. "Flow and joy" coding, the whole Karpathy vibe coding pitch, got quietly rejected by every professional in the study. They said it's fine for throwaway prototypes. Not for anything that ships. The devs still liked using agents. They just don't let the agent drive. Turns out the people who've shipped software for a decade know something the vibe coding influencers don't. Huang et al., UC San Diego. December 2025. Paper in comments.
- 07
@om_patel5 ·
a 58 year old guy just dropped the best take on vibe coding i've ever read. MD. PhD. triple board certified. been writing code since the 1970s. he said Claude Code is the biggest leap in programming he's seen in his entire career. and he's seen every single one. he said Claude Code feels like every major leap in programming history combined into one. the biggest shift he's seen in decades. he's using it to reverse engineer bus commands for his 25 year old Sony CD jukeboxes with ESP32 hardware. said doing it manually would have been "beyond laborious." then someone who had never coded before posted their first project. people started dogpiling on him for messy HTML and having a donation link. his response: who cares if it's messy HTML. the guy is posting about discovering he can build things late in life. and people are checking for em-dashes to decide if he's a bot. more good has been built for the world because of vibe coding than slop has ever been produced. we should be celebrating that, not criticizing it.
- 08
@rauchg ·
Code is an output. Nature is healing. For too long we treated code as input. We glorified it, hand-formatted it, prettified it, obsessed over it. We built sophisticated GUIs to write it in: IDEs. We syntax-highlit, tree-sat, mini-mapped the code. Keyboard triggers, inline autocompletes, ghost text. “What color scheme is that?” We stayed up debating the ideal length of APIs and function bodies. Is this API going to look nice enough for another human to read? We’re now turning our attention to the true inputs. Requirements, specs, feedback, design inspiration. Crucially: production inputs. Our coding agents need to understand how your users are experiencing your application, what errors they’re running into, and turn *that* into code. We will inevitably glorify code less, as well as coders. The best engineers I’ve worked with always saw code as a means to an end anyway. An output that’s bound to soon be transformed again.
- 09
@leerob ·
Code is actually the right abstraction. Too often I see the future of software engineering diminished down to, effectively, writing and reviewing markdown files. Yes, it will be hard to review thousands of lines of agent code. But maybe the takeaway is that you want less code? Rather than just giving up ("well I guess we won't read the code, or we'll read this lossy markdown summary") this should be a signal forcing you to think about better systems. - How can we make our codebase more verifiable? For example, fast/robust/stable tests, or moving to a typed language. - How can we deslop or improve the architecture/abstractions of the code generated by agents? For example, spending more time up front on the codebase architecture/types before yolo generating all of the code. - How are we going to maintain and evolve this codebase over time? The slop compounds. One great solution here is... you guessed it, learning from the past decades of software engineering! For example, you might just have the wrong abstraction entirely, leading to a ton of duplicated code. I think the markdown folks *are* right in some ways. If you are using skills every day, for many different prompts and workflows, isn't that effectively "coding with markdown"? Kinda. There's been plenty of ink spilled on the merits and benefits of skills. To me, skills make your style of working legible for agents. They don't replace code and that's not really the point. In reality, there's this messy and constantly re-evolving future in which both of these things are true: 1. Skills (and markdown) are important for how you give input to the agents and ensure high-quality code & systems are created 2. Looking at the actual code will not be replaced by markdown summaries or a collection of spec documents that ignore the lower level details of the code In summary: reality has a surprising amount of detail (and nuance)!
- 10
@alex_prompter ·
Some of the most starred repos on GitHub right now contain zero runtime code. They're markdown files, skill configs, and prompt collections that change how AI models behave. 6 repos worth knowing about, ordered by stars: 1. obra/superpowers (200K+ stars) A full development methodology delivered as 14 SKILL. md files. Forces your coding agent to write a spec before touching code, enforces test-driven development, and isolates tasks into subagents. Works across Claude Code, Codex, Cursor, and Gemini CLI. Created by Jesse Vincent, accepted into Anthropic's official plugin marketplace. 2. andrej-karpathy-skills (170K+ stars) One CLAUDE. md file. 65 lines. Zero dependencies. Four behavioral rules distilled from Karpathy's viral observations about how AI coding agents fail: think before coding, simplicity first, surgical changes, goal-driven execution. Developer Forrest Chang turned the observations into a file you drop into your project root. Probably the highest-leverage single file you can add to any AI-assisted project. 3. mattpocock/skills (135K+ stars) Matt Pocock's personal .claude skills directory, published as a public repo. 21 skill files built from his daily TypeScript workflow. The standout is /grill-me: the agent asks 50+ detailed questions before writing a single line of code. Sessions run about 45 minutes. By the end you have a richer project spec than most PRDs produce. 4. Everything Claude Code (100K+ stars) Won the Anthropic x Cerebral Valley hackathon. 28 specialized agents, 119 skills, 60 slash commands, and a built-in security scanner. Works across Claude Code, Cursor, Codex, and OpenCode from a single AGENTS. md at the root. The closest thing to a full operating system for your coding agent. Created by Affaan Mustafa. 5. awesome-chatgpt-prompts (100K+ stars) The original LLM behavioral modification repo. A community-sourced collection of system prompts that turn ChatGPT into a Linux terminal, a Socratic teacher, a legal advisor, a debate coach. What CLAUDE. md does for coding agents today, this repo did for ChatGPT conversations years earlier. Still actively maintained. 6. awesome-claude-skills by ComposioHQ (60K+ stars) The directory. 1,000+ production-ready Claude Code skills organized by category: developer tools, document processing, data analysis, business workflows, security. Where the other five repos give you specific tools, this one gives you the map of what's available across the entire ecosystem.
- 11
@akshay_pachaar ·
What they don't tell you about vibe coding: • Moltbook exposed 1.5M auth tokens. The owner hadn't written a single line of code. • Tea App leaked 72,000 government IDs. The database was just open, no sophisticated hack needed. • A researcher took control of a journalist's computer through her own vibe-coded game, without a single click. The code ran fine in all three cases, tests passed, reviews looked clean, and nothing raised a flag. That's the problem nobody is talking about. Teams are shipping faster than ever. AI writes the code. CI catches build failures. Tests catch regressions. Observability catches outages. But nobody is asking the one question that actually matters: What can an attacker do with this, right now? Because the bottleneck is no longer writing code. It's understanding what that code actually exposes once it's live. PR reviews miss auth edge cases. Unit tests don't probe broken access control. Staging environments don't simulate adversarial behavior. And business logic flaws look completely fine until someone decides to break them on purpose. Strix is an open-source tool that fills this gap. It reviews your running app the way an attacker would: - Crawls the app and maps every exposed route and flow - Probes abuse paths dynamically, not just at build time - Returns findings with proof-of-concepts and suggested fixes Strix was benchmarked against 200 real companies and open-source repos, where it found 600+ verified vulnerabilities including assigned CVEs. It's designed to fit into how modern teams already work. Run it before a release, after major changes, or continuously as the app evolves. If your team is shipping AI-generated code and you don't currently have a way to answer "what does this actually expose", it's worth looking at. GitHub link in the next tweet.
Watch video
- 12
@neetcode1 ·
Forgot to post on twitter - my conversation with @thdxr from @opencode Talked a lot about how programming is changing & not changing. I really enjoyed a lot of the historical takes that Dax has. He's building one of these "agentic coding" tools, so he sees the value in it, but he also has a healthy amount of skepticism. A lot of the core debates about "vibe code" vs "traditional code" aren't new. They already existed in many forms, e.g. go fast break things vs overengineering, microservices vs monolith, testing, etc. I also really resonated with his idea of competition - was probably my favorite part, but there were many great ones! 0:00 - Intro 3:56 - Dax's developer workflow 6:54 - Is code no longer written by humans? 11:32 - Competition, Claude Code 19:04 - Positioning vs Product 23:49 - Will OpenAI acquire OpenCode? 28:02 - The Future of Coding, effort vs impact 37:16 - Code Quality 42:23 - Did AI take the fun out of programming? 45:56 - Will programming skills decay long term? 51:56 - Technical skills alone are useless 58:56 - Becoming an Elite Developer Thank you to our sponsors @posthog and @greptile You can find the NeetCode podcast on YT, Spotify & Apple Podcast - links below
Watch video
- 13
@jsmasterypro ·
"AI ruined coding" is the hottest take in tech right now. But what exactly did it ruin? Writing the same CRUD endpoints for the 400th time? Debugging webpack configs? Copy-pasting from Stack Overflow? AI took away the parts I hated and left me with the parts I love: architecture, product thinking, creative problem solving. Coding hasn't been this fun for me in 7 years.
- 14
@hasantoxr ·
🚨BREAKING: A developer on GitHub just built a complete operating system for AI coding agents and it has 40.9K stars on GitHub. It's called Superpowers, and it fixes everything broken about how Claude Code and Codex actually write software. Right now, most people fire up their coding agent and just… let it go. The agent guesses what you want, writes code before understanding the problem, skips tests, and produces spaghetti you have to babysit. Superpowers fixes all of that. Here's what happens when you install it: → Before writing a single line, the agent stops and brainstorms with you. It asks what you're actually trying to build, refines the spec through questions, and shows it to you in chunks short enough to read. → Once you approve the design, it creates an implementation plan detailed enough that "an enthusiastic junior engineer with poor taste and no judgement" could follow it. → Then it launches subagent-driven development. Fresh subagents per task. Two-stage code review after each one (spec compliance, then code quality). The agent can run autonomously for hours without deviating from your plan. → It enforces true test-driven development. Write failing test → watch it fail → write minimal code → watch it pass → commit. It literally deletes code written before tests. → When tasks are done, it verifies everything, presents options (merge, PR, keep, discard), and cleans up. The philosophy is brutal: systematic over ad-hoc. Evidence over claims. Complexity reduction. Verify before declaring success. Works with Claude Code (plugin install), Codex, and OpenCode. This isn't a prompt template. It's an entire operating system for how AI agents should build software. 100% Opensource. MIT License.
- 15
@Hesamation ·
today, I watched this DHH interview for a 2nd time. his approach to AI coding is much more playful and curious than many other experienced devs, and he’s very good at articulating why. some takeaways: “the best programmers are currently more valuable than ever because they’re the ones who are able to get the most out of the ai acceleration.” in his opinion the taste, judgement, and the ability to review what AI produces are unique qualities you gain over time. “maybe we've seen the best of the golden days” seems to be true for the average programmer. the craft was valued for a set of constraints and as they loosen, the salaries would drop. “the number of projects we have tackled internally that we would never even have contemplated starting on are legion.” he does mention some of the downsides of using these tools but his curiosity for them is quite interesting. also great bits on what it means for developers to work in post-AI era. great discussion between @dhh and @GergelyOrosz.
- 16
@lemire ·
Bjarne Stroustrup (creator of C++) recently gave an interview to the StackOverflow blog... He answers a few interesting questions... I share me thoughts after each Stroustrup's quote. 1. What is the best way to handle errors in software ? It depends... « You could terminate the program. Now you don't have the security problem and wrong results. And if you are in a server farm with 40,000 processes, that's probably the right thing to do. Then you could give some kind of error message somewhere. That's a little bit hard to do for a vector access, but in many, many cases, giving an error code will be a reasonable thing, and then you hope people test the error code. And my favorite is to throw an exception. That is, somewhere in your program, you have something that catches all exceptions, and you terminate if that's what you want to do, preferably after giving dump of the information of what caused it, so that you can fix it and you don't get it again next time. Or you have a more specific recovery mechanism, which is needed in some cases. Say if you run out of memory on a small computer that has separate memory banks, things like that. So what is the right answer to that kind of problem? The memory exhaustion, out of range access? It depends on what you're doing. » Things go wrong. What do you do when things go wrong? There is no one strategy that always work. It depends on your specific application. A reasonable option is to just stop, halt. But that's not always what is best! 2. On code guidelines... « I'm working on something called profiles. Note the plural because my experience is that different organizations, different environment, different applications have different criteria. I actually think that people who talk about memory safety and only memory safety are not very realistic. That's more propaganda than it is good engineering. » People often seek some universal coding guidelines, but that's not possible. What is unacceptable in code base A could be desirable in code base B. 3. On safety... « People do what I consider unfair attacks on C++ by using examples from badly written C. And you don't have to have badly written C, and you don't have to have badly written C++. Of course, you can find examples that crash, but you can do that in any language and you do. » I have worked, and I still work, on very large code bases that are mission critical. If you are a competent C++ programmer, you are just not going to see null pointer accesses or memory corruption. I see with students who just started to learn system programming a month or a year ago. Source: https://t.co/uUzc9qLgw1
- 17
@clairevo ·
I have been coding for over 20 years (!!!) and I’m sitting here, mouth agape, watching codex: - planned full refactor of core app, published in a pretty html for my review and co-authorship - iterating through loops to code piece by piece, document and update architecture plans as it goes - every loop does a browser smoke test of new features, identifies and fixes functional and visual regressions (even ones not related to the code!) - maintains lints and tests - my job is to type “ok what’s next” and occasionally auth integrations oh and on the side his buddy codex is 45 minutes into a /goal of cleaning up 4,000 emails in my inbox
- 18
@rohanpaul_ai ·
Chamath on how AI agents are making the "10x engineer" distinction disappear because the most efficient "code paths" are now obvious to everyone. Just as AI solved chess and removed the mystery of the best move, AI is doing the same for coding, making the process reductive and removing technical differentiation. "I'm going to say something controversial: I don't think developers anymore have good judgment. Developers get to the answer, or they don't get to the answer, and that's what agents have done. The 10x engineer used to have better judgment than the 1x engineer, but by making everybody a 10x engineer, you're taking judgment away. You're taking code paths that are now obvious and making them available to everybody. It's effectively like what happened in chess: an AI created a solver so everybody understood the most efficient path in every single spot to do the most EV-positive (expected value positive) thing. Coding is very similar in that way; you can reduce it and view it very reductively, so there is no differentiation in code." --- From @theallinpod YT channel (link in comment)
Watch video
- 19
@anulagarwal ·
Greatest vibe-coding hack (step-by-step): >Code with Opus 4.6 (in Claude Code) >Ask Codex GPT 5.4 to review and make a detailed plan of any problem it finds, why they are a problem, and how they can be solved >Copy plan to Opus 4.6 and ask it to review >Ask Opus 4.6 to implement fixes >Ask Codex to review the fixes Been doing this the past couple of days -> way less bugs, and oneshotting features seamlessly!!
- 20
@LBacaj ·
We’re making a fundamental tradeoff when we use these coding agents, but some of my engineering friends still don’t seem to get it. I see a lot of engineers make the argument “AI outputs still aren’t that great, code quality isn’t the same as writing it by hand.” And it’s all true, their argument is not wrong. But a coding agent can produce in a few hours what would take one of these engineers a month, or more. And I’ll even accept at face value that their well-thought-out, carefully written “artisanal code” would be better. But it would take them 10x longer to get out. So the fundamental thing we’re doing is to take this average code, generated in a day by an LLM, and try to make it a little above average. We are prompting our way onto something we can stand behind and support. And even if that extra work takes let’s say a week & it’s frustrating as hell to get it to something we can stand behind, a week is still better than spending a month or more. So that’s the tradeoff. And if you write code for money, pretty soon, nobody is going to let you take a month to write it carefully. Businesses all exist in a competitive space, if other businesses find a way to move faster by willingly making this tradeoff, they’ll all be forced to work this way. And it’s already happening and it will continue to happen. Then on top of all this, I notice many of us have this old mental model that we are writing code for other humans to extend, to work with, to add features to, etc. And in that world code quality matters a lot. But it’s unclear to me now that other humans will ever extend your code again. If these models improve even a little bit more, models will always be extending your code from now on. In that new world, you have to almost always make this tradeoff and you have to become great at it.
- 21
@VaibhavSisinty ·
The difference between someone getting 20% out of Claude Code and someone getting 100% is five files. Most developers open Claude Code, type a prompt, and hope for the best. The best developers build a system around it. Five layers. Five files. One stack. → CLAUDE.md : the memory. Sets the rules, naming conventions, repo structure. The agent reads this before every task. → SKILL.md : the knowledge. Auto-invoked when the task matches. Scripts, templates, reference material the agent pulls in on its own. → Hooks : the guardrails. Block rm -rf before it runs. Auto-lint on every write. Deterministic rules that fire every time. Not AI. Just rules. → Subagents : the delegation. Separate agents for code review, testing, exploration. Own context. Own permissions. Keeps the main agent clean and focused. → Plugins : the distribution. Bundle everything into one install. Every teammate gets the same setup. Same rules. Same skills. Same guardrails. The old developer stack was frontend, backend, database. The new one is memory, skills, hooks, subagents, plugins. If you're still treating your coding agent like a chatbot, you're leaving 80% of it on the table.
- 22
@bibryam ·
If you missed, check out my latest post 👇 →12 patterns behind production coding agents← 1. Persistent instructions: durable rules repo. Helps consistency. Trade-off: goes stale. 2. Scoped context: load rules by directory. Helps local accuracy. Trade-off: harder to debug. 3. Tiered memory: hot index, cold files, full logs. Helps token efficiency. Trade-off: more memory plumbing. 4. Dream consolidation: background memory cleanup. Helps reduce drift. Trade-off: can prune the wrong thing. 5. Progressive compaction: compress old context in stages. Helps long sessions. Trade-off: loses detail. 6. Explore-plan-act: read first, edit later. Helps avoid blind changes. Trade-off: slower to start. 7. Context-isolated subagents: separate research, planning, editing. Helps reduce context pollution. Trade-off: handoff loss. 8. Fork-join parallelism: parallel subagents on isolated branches. Helps throughput. Trade-off: merge conflicts. 9. Progressive tool expansion: start with few tools, unlock more later. Helps tool selection. Trade-off: expansion logic. 10. Command risk classification: classify commands before execution. Helps safety with less approval fatigue. Trade-off: rigid rules. 11. Single-purpose tools: typed tools for read/edit/search. Helps reliability and permissions. Trade-off: less flexible. 12. Deterministic lifecycle hooks: enforce invariants outside the prompt. Helps consistency. Trade-off: harder debugging. https://t.co/ISHCPHFEv5
- 23
@heygurisingh ·
A new study just destroyed the entire "vibe coding" movement. UC San Diego and Cornell researchers tracked 112 professional developers using AI agents in their real jobs. The result is the opposite of every viral demo on your timeline. Real engineers don't vibe code. They control. Here's what the data actually shows. 13 developers were observed live coding with agents in production work. 99 more filled out a deep qualitative survey. Every participant had at least 3 years of experience. Some had 25. The viral pitch goes like this. Hand the agent a vague prompt. Don't read the diff. Forget the code even exists. Trust the vibes. Andrej Karpathy coined the term. Thousands of developers on X claim they run dozens of agents at once building entire production systems hands-off. Almost nobody serious actually works that way. Here's what experienced developers actually do. → They plan before they prompt. Architecture, constraints, edge cases written out first. Then they hand the agent a tightly scoped task. → They review every diff. Not because they're paranoid. Because they've seen what happens when nobody does. → They constrain the agent's blast radius. Small tasks only. The moment a problem touches multiple systems, they take over. → They treat the agent like a fast junior dev that needs supervision. Not a senior engineer that can be trusted alone. The paper buries something even darker in the citations. A separate randomized trial found experienced open source maintainers were 19% slower when allowed to use AI. A different agentic system deployed in a real issue tracker had only 8% of its invocations result in a merged pull request. 92% failure rate in production. 19% productivity drop for senior devs. The viral demos lied. The biggest finding in the paper is one sentence. Experienced developers feel positive about AI agents only when they stay in control. The moment they let go, quality collapses, and they know it. This matches what every serious shop has quietly figured out. The developers shipping the most with AI aren't the ones vibing. They're the ones with the strictest reviews, the tightest task scoping, and the clearest mental model of what the agent can and cannot do. Vibe coding makes great Twitter videos. It does not make great software. The next time someone tells you they let Claude build their entire SaaS in a weekend, ask how much of that code they've actually read. The honest answer separates real engineers from the demo crowd.
- 24
@zarazhangrui ·
How my own usage of coding agents has changed in the past month: 1. Moved from the terminal to the Codex/Claude Code desktop apps. The Codex Mac app is especially great. Now I rarely open the terminal 2. Transitioned from mostly Claude Code to 50-50 Claude Code and Codex. Codex feels like a very reliable engineer; Claude Code is a better PM and designer with good communication skills So I go to Codex if I already have a defined task and just need it to work; I go to Claude Code if I don't yet know what I want and just wanna brainstorm/prototype
- 25
@Shruti_0810 ·
99% of developers are using Claude Code like it's ChatGPT. That's the mistake. They open a terminal. Ask for a feature. Wait for an answer. Power users? They're running entire engineering systems from prompts. Debugging. Code reviews. Automation. Multi-agent workflows. Project memory. All inside Claude Code. So I took dozens of docs, Reddit deep dives, hidden commands, and advanced workflows... ...and condensed everything into ONE visual cheat sheet. What's inside? • Hidden CLI commands • Session & memory management • Advanced debugging workflows • Autonomous agent loops • Multi-agent orchestration • MCP integrations • Review & lint pipelines • Reasoning controls • Monitoring & reporting • Keyboard shortcuts • Productivity hacks almost nobody talks about A few gems: → /compact Shrinks context without losing important information. → /review Turns Claude into a senior engineer reviewing your codebase. → /think Most people ignore it. The difference on complex problems is wild. → /agents + /auto Build repeatable workflows that feel like having extra teammates. → /memory Project-level instructions that make Claude smarter every session. The biggest realization? Claude Code isn't just an AI coding assistant. It's an operating system for software development. Once your workflows are dialed in: • PR reviews happen faster • Bugs get isolated quicker • Repetitive work disappears • Context switching drops dramatically • Shipping speed compounds The gap between average users and power users is no longer coding skill. It's workflow design. Bookmark this. Future you will thank you. 👇
- 26
- 27
@manthanguptaa ·
This talk from @badlogicgames is such a wake up call and something I have been saying for a while. Slow the F down with this agentic vibe coding. We are already seeing the consequences. More breaking software than ever, constant instability in dev tools, and a noticeable spike in security incidents, especially around supply chain attacks and poorly reviewed code getting shipped into widely used systems. And then you see companies proudly saying “100% of our code is written by agents” like it’s a flex. It’s not. If anything, it’s a signal that nobody is actually reviewing what’s being shipped with the level of care required, especially when you are building IDEs, terminals, libraries, and infra that thousands or millions of developers depend on. We have literally seen what happens when velocity outpaces discipline. Packages with massive adoption are getting compromised, critical tools are breaking under edge cases, and systems are becoming harder to debug because nobody fully understands the code anymore. When something goes wrong, you are not debugging your system, you are reverse engineering what an agent decided to do. The whole “tokenmaxxing” mindset is also broken. Pushing billions of tokens through agents isn’t a flex if the output is over-engineered, brittle, and hard to maintain. LLMs have a natural tendency to expand complexity, not reduce it, and if you are not actively constraining that, you are just accumulating invisible tech debt at scale. There’s also this narrative that “it doesn’t matter because agents will read the code anyway,” but that falls apart the moment your system grows. Codebases become bloated, abstractions pile up, and reliability drops. At some point, humans still have to step in, and now they are dealing with a system that was never designed with clarity in mind. We are optimizing too much for speed and output, and not enough for correctness, simplicity, and long-term maintainability. And that tradeoff is already showing cracks. Shipping fast is great. Shipping blindly isn’t.
- 28
@Suryanshti777 ·
Most people use Claude Code like a smarter autocomplete. Senior engineers use it like an operating system. The real upgrade isn’t faster typing. It’s splitting software development into parallel AI workflows: → one agent researches → one plans architecture → one writes code → one reviews → one stress-tests edge cases Everything documented. Everything isolated. Everything running simultaneously in separate worktrees. That’s the shift. The best AI engineers are no longer just coding faster. They’re orchestrating teams of agents like technical directors. A single developer can now run 5–10 parallel engineering streams at once. And honestly, that changes the definition of “solo developer” forever.
Watch video
- 29
@Franc0Fernand0 ·
I think vibe coding is great for experienced developers. It’s a way to turn out a lot of good code very quickly. An experienced developer can learn how to write prompts that get the job done and reduce the chance of mistakes. After that, they can carefully look over the code and change it if needed. It’s a tremendous productivity boost. But when a non-programmer uses AI to write code, it’s not going to end well.
- 30
@zaimiri ·
Codex just dropped plugins and nobody's talking about it. One install = your coding agent now connects to your entire stack. The ones I'm using: • Linear - assign issues to Codex, it codes and posts the PR back • Slack - @Codex in any channel to kick off tasks from conversations • GitHub - manage PRs, review code, push changes directly • Google Drive - pull docs, sheets, slides into your codebase context • Gmail - read and manage emails without leaving your workflow Before plugins: Codex was a coding agent. After plugins: Codex is your entire dev team's operating system. Save this for later.
- 31
@lemire ·
Will a new engineer know how to read code? When I was a kid, most people did not know how to type. We had an actual typing class where you had to learn the technique. The final exam was a speed typing test: how many words a minute could you type? You are not going to impress anyone today by saying that you can type on a keyboard. In fact, only 40 years ago, the default was cursive writing. Yet cursive writing is going away. Increasingly, kids cannot read or write in cursive. We type all the time. We forget how many of our skills are learned—and how many are forgotten. Reading and writing in English or Persian is not innate. Writing integrals is not innate. Reading and writing code is not innate. They all require substantial training. I have now encountered more than one student who could use AI to build an application but who cannot read or write code. It is not entirely new. We have had “non-technical” people in software forever—people who tell you how they built this or that, or how they designed the first X or Y. In fact, the standard a few decades ago was that once you had a university degree, you were not supposed to code. You were an analyst. Coding was for monkeys or low-status employees in many organizations. I am an actual university professor and I code. I code boring stuff in Java, C, and Python. Few professors code. It is low status. So why do I do it? What about top engineers? The engineer paid a million dollars a year at Google or Meta knows how to write code. They can often read and write in assembly and TypeScript. They know it all. In effect, whether you should learn to write code has always depended on context. If you work for a typical government agency, code is entirely secondary. It is as important as how the chairs are nailed together or how the windows open. It has to work, but nobody cares beyond the strict minimum. But you are not going to earn $1M a year writing code in a government agency. So what will happen? My theory is that what will happen is much like what happened with the arrival of television and video. It was felt that people would stop reading. We would go back to the world of Socrates, who famously resisted the written word. But the opposite happened. We have never read and written as much as we do now. And there are more people than ever making a living while writing all day long. I suspect that top engineers will end up reading code, and sometimes writing code, at speeds previously limited to a tiny elite. These top engineers will not be everywhere. They will not be in every organization. But they will pack a punch. Why? Because we do not have a better alternative for communicating software from brain to machine and machine to brain. “But Daniel, people say that software programming is a solved problem. Why would anyone read or write code in the future?” You have to be careful with your models. When television arrived, people predicted that we could just replace the university lecturer with a TV show. In some respects, this model is not wrong. But it did not happen because the job of the university lecturer was never to offer the equivalent of a TV show. Similarly, the Google engineer paid $1M a year was never a machine to produce code. Nobody actually wants code, just as nobody wants text. Here is what concretely is going to happen to an engineering team where nobody can read or write code. They will be reading what the AI says about the code. And they will understand about as much as a manager understands the code written by their engineers: not much at all. The reason we pay an engineer $1M a year is because he understands concepts that few people do. He can outrun others because he understands the problems more deeply. And reading and writing code, a lot of it, is part of how you get deep insights. Chatting with Claude Code won’t turn you into a top 1% programmer.
- 32
@Layton_Gott ·
Can we stop pretending manual code is written perfectly every time? Stanford and MIT studied over 2 million code snippets in March 2026. 9.1% of human-written code had security vulnerabilities. That's not AI code. That's YOUR code. Yes AI had more at 14.3%. Nobody's denying that. But here's what the same studies found: Developers using AI complete 26% more tasks. That's from MIT studying 4,867 engineers at Microsoft and Accenture. GitHub's data shows AI users merge 60% more pull requests per day. Developer onboarding time has been cut in half since AI tools became standard.. Every single one of these studies was done BEFORE Claude Opus 4.7 and GPT-5.5 launched. The two most capable coding models ever built didn't exist when this data was collected. AI learns from every great developer on earth. Every day. Every model update. Your code quality peaked years ago. AI's is just getting started. The gap in quality is shrinking daily. The gap in speed is only getting wider. Stop arguing about whether AI code is perfect. Learn to guide it so well the speed gap buries everything else.
- 33
@nurijanian ·
PMs have been "vibe-coding" since the dawn of times, we just didn't call it that when AI writes your code, your job is managing code you can't fully read. isn't this what PMs used to do before? have any of you actually looked at the code your eng team wrote? there's this great talk from an Anthropic member of technical staff, here are 10 things from his talk that PMs should pay close attention to: 1. most people saying "i vibe code" aren't vibe coding. Andrej Karpathy's actual definition (he coined the term): fully give into the vibes, embrace exponentials, forget the code even exists. if you're reviewing every diff Claude produces, you're doing AI-assisted coding, which is a different skill than what will matter in 12 months. 2. AI task length is doubling every ~7 months. right now it handles about an hour of work. in two years, a full week. you can review an hour of output, but you can't review a week of output line by line, and lock-step human review doesn't survive that curve. 3. we've seen this before with compilers. early compiler users insisted on reading the assembly output. it made sense when programs were small and stopped making sense fast. AI-written code is at the "reading the assembly" stage right now. 4. Erik's framing: forget the code exists, but not the product. same move as forgetting assembly but still knowing software. your verification layer moves up one level of abstraction, and the code becomes an implementation detail you manage through outcomes. 5. managing work you can't fully audit is as old as civilization. every CTO manages engineers whose code they can't all read, and every PM ships features they didn't write. engineers are catching up to a problem the rest of the company solved a long time ago. 6. i think engineers are uniquely unprepared for this because their professional identity is built around full-stack IC mastery and understanding the entire depth of the stack. that identity has to change, and it's the same transition PMs already went through: learning to ship things you didn't build by verifying outcomes instead of inspecting implementations. 7. acceptance tests beat implementation review. Erik writes three end-to-end tests: one happy path, two error cases. he reads only the tests, and if he agrees with what they check and they pass, he trusts the code. this is how PMs have written acceptance criteria for decades. 8. dogfood the product, not the code. use it, check it behaves as expected, don't read the source. this has been the PM move since the role existed, because your judgment about product quality comes from experiencing the product, not auditing the implementation. 9. spot-check key facts, not the whole artifact. the CEO/CFO move on financial models: pick three slices you understand deeply, verify those, trust the rest conditional on those holding. Erik applies this to AI-generated code, and PMs apply it to engineering output every sprint. 10. before touching an unfamiliar codebase, map it first. ask Claude where auth happens, what classes matter, what's similar to what you want to build. build the mental picture before writing a line, which is PM discovery applied to code. by the way, here's a skill to help PMs find vibe-code friendly parts of the code: https://t.co/NHUQrCSmz8
- 34
@Trader_XO ·
I’ve been thinking about this a lot lately - Agentic Coding and framework choice. As someone who’s comfortable with TypeScript with Nest, C# with .Net Core, Python Fast API, and Go, when it comes to building a bunch of APIs, I’ve found myself pausing less to ask can I build this in any of these stacks? and more to as to which one am I actually choosing, and why? Because with agentic coding, the equation feels like it’s changing. The value seems to be shifting away from just how fast you can write code by hand, and more toward how well you can think through systems, make good engineering decisions, and work in a way that lets you build and adapt confidently. So for me, stack choice starts to feel less like a question of personal coding preference and more like a question of leverage. Which ecosystem is the most versatile? Which codebase will be easiest to read, understand, and safely change later? Which stack will make the system easier to operate and maintain over time? I don’t think the takeaway is that coding skill no longer matters, it does. It’s more that code comprehension, design judgment, and maintainability may matter more now than raw implementation speed. That’s what makes the question interesting to me nowadays... - Not just how do I build the APIs? but which stack actually gives me the best long term leverage? Rhetorical Questions...
- 35
@Hartdrawss ·
Hot Take : Vibe coding will NOT replace developers. The argument is wrong. Here's exactly why. Vibe coding replaces the tedious parts — boilerplate, CRUD scaffolding, first drafts of UI, repetitive patterns. It does not replace: > Knowing what to build in the first place > Designing a system that doesn't collapse at scale > Reviewing AI output for security vulnerabilities (and there are many) > Debugging the production incident at 2 AM that AI has no context for > Making the 50 architectural decisions that determine if the product survives year one > Understanding the customer problem well enough to know what the software actually needs to do What's being replaced is the developer whose entire value was "I write code." What isn't being replaced is the developer whose value is "I solve problems, design systems, and take responsibility for what gets built." The developers winning are the ones who always knew "solving problems" was the job. It's just has honestly made the processes rapid; but getting aligned still needs more and more great engineer !
- 36
@smratitiwa86867 ·
Everyone is arguing about which AI writes the best code. GPT vs Claude. Claude vs Gemini. Wrong debate. The developers shipping the fastest all follow the same rule: They don't just prompt AI. They give AI a system to think in. This 1-page document by Andrej Karpathy is one of the best examples I've seen. It isn't a prompt. It isn't a framework. It's a set of engineering principles that makes any coding model dramatically more reliable. Here are the biggest takeaways: • Read before you write. AI loves to invent patterns. Make it understand the existing codebase before touching anything. • Think before you code. Have the model explain its plan first. Bad assumptions are cheaper to catch than bad code. • Write the simplest solution. Don't optimize for imaginary future requirements. Solve today's problem cleanly. • Keep changes small. A 20-line PR is easier to review, test, and trust than a 500-line AI-generated rewrite. • Testing isn't optional. Code that compiles isn't necessarily code that works. Every change needs proof. • Debug with evidence, not guesses. Read the full error. Reproduce the bug. Change one thing at a time. • Every dependency has a cost. Before installing another package, ask if the standard library already solves it. • Measure success before you start. If you can't define what "done" looks like, AI can't either. The biggest lesson? AI doesn't replace software engineering principles. It amplifies them. A developer with good engineering habits can get incredible results from an average model. A developer with poor habits will get unreliable code from the best model on Earth. The AI model matters. Your workflow matters even more. This is one of those documents every AI engineer should read at least once. Bookmark it. Six months from now, these principles will matter more than whichever model tops the benchmarks. 🚀
- 37
@nurijanian ·
Saw the Claude Code vs Cowork debate on r/PM. Here's the framework I'd actually use: 1. Cowork wins for one-off work. Writing a doc, quick research, visualizing a decision you won't revisit. It's faster if you're not building something that needs to persist. 2. Cowork also wins on inline canvas rendering. Seeing Claude generate visuals for a decision, right in the chat, cuts iteration time. Code requires switching to files. 3. I think Claude Code wins for anything meant to compound. Hooks, skills, and custom instruction files survive sessions. 4. Code wins for codebase access. Reading PRs, tracing bugs, explaining features to engineering without pinging anyone. Code is the only tool that can do this. 5. Code wins when you want to connect to your own data. Database queries, S3, custom scripts you've already built. Cowork doesn't support this. 6. If you use Obsidian or any second brain, I've found Code is the only option that works. The most impressive setup in that thread was a non-coding PM who built 50 custom hooks, auto-logged meeting transcripts, and made all of it AI-searchable across sessions. 7. Enterprise and regulated environments usually default to Code anyway. AWS Bedrock deployments, no-Cowork policies, screen-sharing security concerns. The debate is moot for a lot of orgs. 8. Best team stack: Code builds, Cowork consumes. Data pipeline in Code, results surfaced in Cowork for non-technical teammates. 9. You don't need to be a developer to use Code. The setup is trivial. 10. Most PMs are using Cowork like a better ChatGPT. That's fine. But if you want your AI work to compound, I'd use Claude Code.
- 38
@ekzhang1 ·
had a random thonk today after scrolling through lots of demos I used to think about coding as “not only can we solve problems, we have the unique power to make digital media. coding lets us make objects of _interaction_ that people can use and enjoy” but with the LLMs getting really good at specialist web development it’s no longer the case, I guess anyone can make interactive artifacts with computers :) — exciting times it does mean I have kind of a missing hole in my life philosophy that I need to think about a bit more though, what do i value most
- 39
@smratitiwa86867 ·
Claude Opus 4.7 didn’t just improve coding. It quietly killed the way most developers think about coding. But almost no one is using it the way Andrej Karpathy describes. People are still stuck in: “write this function” “fix this bug” “explain this code” That’s not wrong. It’s just… low-leverage thinking. Karpathy’s real idea? 👉 You don’t write code anymore. 👉 You design systems. 👉 You steer intelligence. And once you see it… you can’t go back. Here are 10 advanced prompts to use Claude Opus 4.7 like an actual engineering partner (not a tool):
- 40
@milan_milanovic ·
𝗦𝘁𝗮𝗰𝗸 𝗢𝘃𝗲𝗿𝗳𝗹𝗼𝘄 𝗱𝗶𝗱𝗻'𝘁 𝗷𝘂𝘀𝘁 𝗴𝗲𝘁 𝗿𝗲𝗽𝗹𝗮𝗰𝗲𝗱 𝗯𝘆 𝗔𝗜 𝗜𝘁 𝗹𝗶𝘁𝗲𝗿𝗮𝗹𝗹𝘆 𝘁𝗿𝗮𝗶𝗻𝗲𝗱 𝗶𝘁𝘀 𝗼𝘄𝗻 𝗿𝗲𝗽𝗹𝗮𝗰𝗲𝗺𝗲𝗻𝘁 There was a time when coding meant hitting a wall... and opening 5 tabs of Stack Overflow, desperately searching for that one green-ticked answer from 2012 Before ChatGPT, Claude, or DeepSeek, there was only one place where we could: • Find that one missing semicolon • Decode that cryptic error message • Copy that perfectly working code snippet (with fingers crossed) Every developer's journey was incomplete without silently whispering, "God bless this person," to some anonymous hero who posted the exact solution you needed Today, we just ask AI for instant help But here's the twist: Every AI helping you code was trained on Stack Overflow's data That regex ChatGPT just wrote? Learned from Stack Overflow Claude's debugging advice? Trained on millions of SO answers DeepSeek's code suggestions? Fed Stack Overflow's knowledge base 𝗦𝘁𝗮𝗰𝗸 𝗢𝘃𝗲𝗿𝗳𝗹𝗼𝘄 𝗯𝘂𝗶𝗹𝘁 𝘁𝗵𝗲 𝘄𝗼𝗿𝗹𝗱'𝘀 𝗺𝗼𝘀𝘁 𝗰𝗼𝗺𝗽𝗿𝗲𝗵𝗲𝗻𝘀𝗶𝘃𝗲 𝗽𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗯𝗮𝘀𝗲, 𝘁𝗵𝗲𝗻 𝘁𝗵𝗮𝘁 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗯𝗮𝘀𝗲 𝘁𝗮𝘂𝗴𝗵𝘁 𝗔𝗜 𝗵𝗼𝘄 𝘁𝗼 𝗿𝗲𝗽𝗹𝗮𝗰𝗲 𝗶𝘁 Ultimate "I raised you" moment in tech history. End of an era. Start of a new one. What's your most memorable Stack Overflow save?
- 41
- 42
@ujjwalscript ·
The "AI makes you a 10x Developer" you keep seeing on X is an ABSOLUTE illusion. And the empirical data finally proves it! The overwhelming consensus right now is that AI coding tools make every developer 10x faster, rendering foundational learning obsolete. Here is what the actual, data-backed reality looks like: 1. The "Time Savings" Illusion: A study by METR tracked experienced contributors tackling tasks in complex codebases. While developers predicted AI would save them 24% of their time, using AI actually increased completion time by 19%. Why? Because models generate syntactically correct code that completely misses broader system architecture, forcing engineers to waste hours debugging out-of-context boilerplate. 2. The Comprehension Trap: A randomized trial by Anthropic analyzed developers learning a new framework. Those who relied on AI to generate their code scored 17% lower on comprehension tests. When you treat AI as a typewriter instead of a sounding board, your brain skips the critical cognitive heavy lifting. 3. The Junior Bottleneck: A Harvard-backed study tracking tech worker records revealed that companies adopting generative AI cut junior developer hiring by 9% to 10%, while senior roles remained entirely flat. AI isn't replacing engineers—it's replacing the entry-level code-typists.
- 43
@hugobowne ·
"For decades I was all in on Python. Now I don't care. TypeScript, Go, Rust, whatever. Verification isn't about looking at the code, it's whether it actually does what it needs to do." -- @intellectronica (ex-Google, ex-Microsoft, now at Jimini Health) Yesterday I spent 3.5 hours, honestly more than I should have, learning from expert builders on Show Us Your (Agent) Skills. The biggest takeaway: people aren't just writing less code, they're reading less. And this is in agentic engineering, not vibe coding. @honnibal (creator of @spacy_io ) puts Claude in "pre-mortem mode" with a skill that reads production code and writes incident reports for bugs that haven't happened yet but plausibly could, the moment a future dev makes a reasonable-looking change. @nicolaygerold (building @AmpCode at @Sourcegraph) flips that with a post-mortem skill: when an agent screws up, it gets the agent to introspect on which instruction in its context caused the failure. Defaults to removing instructions, not adding more. Full ep: https://t.co/yKKOPsG6gj
Watch video
- 44
@heyrimsha ·
Explyt just made every AI coding tool look basic at debugging. Cursor, Copilot, and the rest all debug the same way: read the code, guess what the runtime is doing. Explyt hooks into the JetBrains debugger directly. Real breakpoints. Real variable state. Real call stacks. Real fixes. Here's how with real examples: Full thread 🧵
- 45
@shekhar_tw ·
GitHub went down today. And for a few seconds, my first reaction was: “Well… I guess I can’t work.” Then I realized how stupid that sounded. Because GitHub being down doesn’t mean Git is down. Your code is still on your machine. Your branches are still there. Your commits still work. You can still build features. You can still run tests. You can still refactor code. You just can’t push it somewhere for a while. And I think this is something a lot of developers—especially when starting out—accidentally mix up: Git and GitHub are not the same thing. Git is the version control system running locally on your machine. GitHub is a platform built around Git that gives us things like: remote repositories pull requests code reviews issues CI/CD integrations collaboration When you run: git add . git commit -m "fix: something" None of that requires GitHub. Your commit exists locally. You could make 20 commits, create 5 branches, merge them, rebase them, inspect your history, revert something you broke… all without an internet connection. So instead of treating the outage as a reason to stop working, I started looking at everything I could do locally. I cleaned up some code I had been ignoring. Removed a few unnecessary pieces. Fixed TODOs that had been sitting there for weeks. Looked at some ugly functions and asked: “Why did I write it like this?” Refactored a few things. Ran the application locally. Tested flows I normally don’t spend enough time testing. And made proper commits for everything. Then there was another useful realization: We’ve become so dependent on cloud tools that sometimes we forget how much of software development is still completely local. GitHub can go down. Vercel can go down. Railway can go down. AWS can go down. Your AI coding assistant can stop responding. Your internet can disappear. But if losing one external tool means you literally cannot make progress anymore, your workflow might be more dependent than you think. There’s also another lesson here: Learn the tools underneath the tools. Don’t only learn how to click “Create Pull Request” on GitHub. Learn git diff. Learn git log. Learn branches. Learn commits. Learn rebasing. Learn merging. Learn how remotes actually work. Learn what origin means. Learn what happens when you run: git push origin main Because once you understand the underlying system, the platform becomes just an interface around something you already understand. The same thing applies everywhere in development. Don’t just learn an ORM. Understand SQL. Don’t just learn Next.js. Understand HTTP, browsers, caching and rendering. Don’t just learn Docker commands. Understand processes, ports, filesystems and networking. Don’t just learn how to prompt an AI coding tool. Understand the code it generates. Abstractions are incredibly useful. But fundamentals are what save you when the abstraction stops working. So GitHub went down. I didn’t get to push my code for a while. But I probably learned and cleaned up more than I would have if everything had been working normally. Sometimes an outage is a surprisingly good reminder: the platform is not the skill. The fundamentals are.
- 46
@localjulius ·
AI psychosis is the new burnout. The Karpathy thread crystallized a phenomenon that's been building among developers. > Compulsive 16-hour AI coding sessions > FOMO driven over production > Building things nobody validated A developer spent 2 weeks running Opus 4.6 at max, built 15,800 lines of Rust with 449 tests then discovered no one wanted it. And this is just one of many stories. The dopamine loop (build fast → launch → emptiness) is creating a new class of technical debt that isn't about code quality.
- 47
@jamesdevonport ·
I've been using the desktop apps for Claude Code & Codex daily for the last year or so to do everything from generating videos, to coding iOS apps to managing databases. It feels like the pace of improvement for both has massively ramped up over the last month or two with a never ending stream of updates. Here’s my write-up of what it’s been like using both as a non-coder - where each one shines, where they fall short, and how they differ in real day-to-day use. I love using them both and switch between them frequently but have been finding myself using Codex a lot more lately! https://t.co/mAm9gNtlj1
- 48
- 49
@NainsiDwiv50980 ·
The biggest upgrade to AI coding this year isn't a new model. It's a browser. Claude Code now has a built-in browser that can read websites, click through apps, fill forms, reproduce bugs, and verify fixes—all without leaving your coding environment. That sounds small. It's not. For decades, development has looked like this: IDE → Browser → Docs → Dashboard → Back to IDE → Repeat. Every context switch breaks flow. Claude collapses all of it into one workspace: • Chat • Browser • Terminal • Editor • Diff • Verification One environment. One context. The implications are much bigger than "AI can browse the web." You can now say: > "Find the checkout bug, fix it, test the payment flow, and make sure it works." Claude can: 1. Open the app 2. Navigate the flow 3. Reproduce the issue 4. Write the fix 5. Test the fix 6. Verify everything automatically That's not code generation. That's workflow automation. And Anthropic built it with guardrails: • Sandboxed browser • Separate browser profile • Permission approvals • Optional persistent sessions We're watching the developer stack evolve from: AI inside your IDE to an autonomous development environment. The developers who win in the next few years won't be the ones who write prompts. They'll be the ones who learn how to delegate entire workflows to AI. Less context switching. More shipping. And this launch feels like the first real glimpse of what the future of software development looks like.
- 50
Best Tweets by Topic