AI Code Quality & Verification
AI-generated code quality, including overengineering, debugging limits, security, technical debt, testing, and human verification.
46%
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
- 42
- Updated
Original Xholic analysis
What 50 top Coding posts reveal
Across 50 coding posts, AI Code Quality & Verification was the largest theme at 46%. Vibe Coding Debate accounted for 36% and Agentic Coding Workflows for 34%. The discussion pairs enthusiasm for faster building with recurring calls for clear specifications, testing, review, and guardrails. The supplied outliers include both highly shareable stories and practical workflow content.
- Dominant tone
- Positive
- Median score
- 62.6
- Leading format
- Opinion
- Recent posts
- 36%
52% of posts
All-time engagement
54% of posts
Published in 90 days
Conversation map
The themes creators return to
Developer Role Transformation
How AI changes developer roles, skills, careers, and the value of judgment, architecture, product sense, and domain expertise.
40%
Vibe Coding Debate
The debate over vibe coding: democratized building and rapid prototyping versus disciplined, review-driven engineering.
36%
Agentic Coding Workflows
Coding agents as autonomous collaborators that plan, implement, test, debug, and execute long-running tasks.
34%
Agent Context & Guardrails
Persistent instructions, skills, hooks, memory, context files, and guardrails for shaping reliable agent behavior.
22%
AI Coding Tools & Models
Comparisons, adoption patterns, and practical workflows for Claude Code, Codex, Cursor, Copilot, and related coding tools.
22%
Multi-Agent Orchestration
Managing multiple agents through subagents, worktrees, parallel tasks, competing implementations, and diff-based review.
20%
Spec & Outcome-Driven Development
Specs, requirements, acceptance tests, runtime evidence, and outcome-based validation replacing code-first workflows.
12%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 137
- Median reposts
- 13
- Median replies
- 19
- Median views
- 12.2K
Posts with media make up 58% of this collection. Their median all-time score is 64.7, compared with 39.3 for text-only posts.
Format mix
- Opinion 54% · score 32.8
- Announcement 28% · score 64.3
- List 10% · score 256.8
- Tutorial 6% · score 95.5
Consensus and debate
Where creators agree, and where they do not
Shared view
Agents need direction and verification
Multiple posts advocate treating agents as supervised collaborators: scope tasks, set success criteria, test results, and review changes before shipping.
Shared view
Judgment becomes the developer’s leverage
Posts repeatedly frame the developer’s role as moving toward defining requirements, weighing trade-offs, designing systems, and owning what ships, rather than only writing implementation.
Shared view
Context files become workflow infrastructure
These posts present persistent instructions, skills, hooks, and context-isolated subagents as ways to make agent behavior more consistent and to constrain changes.
Open debate
Vibe coding divides builders and reviewers
Posts split between presenting vibe coding as a way to broaden who can build and arguing that production work requires planning, diff review, and constrained agent autonomy.
Open debate
The verification layer is contested
Some posts argue for verifying AI-produced work through acceptance tests and product outcomes, while others argue that unread generated code raises security, debugging, and maintainability concerns.
What performs
Patterns behind standout posts
Outliers span stories, workflows, and resources
The five supplied outliers cover a source-code leak story, agentic-workflow commentary, a guardrail file, a vibe-coding argument, and a resource roundup. Their all-time scores range from 810.16 to 14874.26.
Media posts had a higher median score
Posts with media had a median all-time score of 64.659, versus 39.348 for text posts. There were 29 media posts, or 58% of the 50-post set.
Statistical standouts
- View standout post 1 Score 14874.3 · 237.76× median
- View standout post 2 Score 5918.5 · 94.61× median
- View standout post 3 Score 3467.7 · 55.43× median
- View standout post 4 Score 1713.3 · 27.39× median
- View standout post 5 Score 810.2 · 12.95× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. anul agarwal
@anulagarwal
2 posts
-
2. Guri Singh
@heygurisingh
2 posts
-
3. Layton Gott
@Layton_Gott
2 posts
-
4. Dr Milan Milanović
@milan_milanovic
2 posts
-
5. George from 🕹prodmgmt.world
@nurijanian
2 posts
-
6. Om Patel
@om_patel5
2 posts
Workflow posts emphasize orchestration and review
These posts recommend bounded delegation, parallel or separate agent sessions where tasks are independent, and inspection of plans, fixes, or diffs rather than relying on a single prompt.
Lists had the highest median format score
List-format posts had the highest format median all-time score in this set: 256.765, compared with 32.75 for opinion posts. The cited examples are resource and tooling lists.
Since the previous snapshot
What changed since Aug 7, 2026
- 78% of the selected posts remained.
- The creator count changed by -1.
- 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 42 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
@naval ·
Vibe Coding Is the New Product Management “There’s been a shift—a marked pronouncement in the last year and especially in the last few months—most pronounced by Claude Code, which is a specific model that has a coding engine in it, which is so good that I think now you have vibe coders, which are people who didn’t really code much or hadn’t coded in a long time, who are using essentially English as a programming language—as an input into this code bot—which can do end-to-end coding. Instead of just helping you debug things in the middle, you can describe an application that you want. You can have it lay out a plan, you can have it interview you for the plan. You can give it feedback along the way, and then it’ll chunk it up and will build all the scaffolding. It’ll download all the libraries and all the connectors and all the hooks, and it’ll start building your app and building test harnesses and testing it. And you can keep giving it feedback and debugging it by voice, saying, “This doesn’t work. That works. Change this. Change that,” and have it build you an entire working application without your having written a single line of code. For a large group of people who either don’t code anymore or never did, this is mind-blowing. This is taking them from idea space, and opinion space, and from taste directly into product. So that’s what I mean—product management has taken over coding. Vibe coding is the new product management. Instead of trying to manage a product or a bunch of engineers by telling them what to do, you’re now telling a computer what to do. And the computer is tireless. The computer is egoless, and it’ll just keep working. It’ll take feedback without getting offended. You can spin up multiple instances. It’ll work 24/7 and you can have it produce working output. What does that mean? Just like now anybody can make a video or anyone can make a podcast, anyone can now make an application. So we should expect to see a tsunami of applications. Not that we don’t have one already in the App Store, but it doesn’t even begin to compare to what we’re going to see. However, when you start drowning in these applications, does that necessarily mean that these are all going to get used or they’re competitive? No. I think it’s going to break into two kinds of things. First, the best application for a given use case still tends to win the entire category. When you have such a multiplicity of content, whether in videos or audio or music or applications, there’s no demand for average. Nobody wants the average thing. People want the best thing that does the job. So first of all, you just have more shots on goal. So there will be more of the best. There will be a lot more niches getting filled. You might have wanted an application for a very specific thing, like tracking lunar phases in a certain context, or a certain kind of personality test, or a very specific kind of video game that made you nostalgic for something. Before, the market just wasn’t large enough to justify the cost of an engineer coding away for a year or two. But now the best vibe coding app might be enough to scratch that itch or fill that slot. So a lot more niches will get filled, and as that happens, the tide will rise. The best applications—those engineers themselves are going to be much more leveraged. They’ll be able to add more features, fix more bugs, smooth out more of the edges. So the best applications will continue to get better. A lot more niches will get filled. And even individual niches—such as you want an app that’s just for your own very specific health tracking needs, or for your own very specific architectural layout or design—that app that could have never existed will now exist.”
Watch video
- 05
@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
- 06
@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.
- 07
@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.
- 08
@om_patel5 ·
SENIOR ENGINEERS ARE QUIETLY SWITCHING FROM CLAUDE CODE TO CODEX AND HERE'S THE BRUTAL BREAKDOWN a 14-year principal engineer spent ~120 hours co-developing (not vibe coding) across both tools on an 80k LOC python/typescript project. here's what he found: Claude feels like an engineer on a time crunch: > speeds toward getting things working > ignores CLAUDE.md at least once per session > leaves tasks half-done mid-migration > changes tests to match what IT thinks the goal is > almost never creates new files — just bloats existing ones Codex feels like a 5-6 year senior: > stops mid-task to rethink and refactor unprompted > never once ignored AGENTS.md > doesn't extend god classes — it factors them out > does things you hadn't thought of that are actually additive > you can fire it off and come back when it's done the raw numbers: > Claude: more done per session, more cleanup every few days > Codex: 3-4x slower, but the work is just better > Codex Pro x5 ≈ Claude Max x20 in usage caps the real difference: > Claude needs a skilled, focused driver or it goes off the rails > Codex demonstrates competence and earns autonomy his verdict: > vibe coding a weekend project? Claude wins > building enterprise software? Codex wins "Claude requires a skilled, focused driver more than Codex does" both give crap output if you don't know SWE. the tool isn't the skill.
- 09
@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.
- 10
@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.
- 11
@socialwithaayan ·
40 GITHUB REPOS THAT ARE ACTUALLY USEFUL 1. public-apis — free APIs for everything 2. build-your-own-x — learn by building 3. developer-roadmap — learn any tech skill 4. free-programming-books — thousands free books 5. system-design-primer — ace any interview 6. coding-interview-university — self taught CS degree 7. the-art-of-command-line — master terminal 8. project-based-learning — learn by doing 9. you-dont-know-js — master JavaScript deeply 10. the-book-of-secret-knowledge — hacker resources 11. tech-interview-handbook — crack any interview 12. awesome-selfhosted — host your own apps 13. javascript-algorithms — learn algos visually 14. 30-seconds-of-code — short useful snippets 15. gitignore — templates for every language 16. ollama — run AI models locally 17. langchain — build AI apps fast 18. n8n — automate workflows with AI 19. openclaw — personal AI assistant locally 20. dify — build AI agents visually 21. langflow — drag and drop AI pipelines 22. mem0 — memory layer for AI agents 23. browser-use — let AI control browser 24. ruflo — agent orchestration for Claude 25. crewai — multi agent AI teams 26. hermes-agent — open source AI agent 27. markitdown — convert any file to markdown 28. maigret — OSINT across 3000+ sites 29. open-webui — self hosted ChatGPT interface 30. aider — AI pair programming in terminal 31. agency-agents — full AI agency in one prompt 32. tradingagents — multi agent trading framework 33. browserbase-skills — Claude web browsing SDK 34. autogen — Microsoft multi agent framework 35. metagpt — AI agents as a software company 36. lobe-hub — visual multi agent platform 37. huggingface-transformers — foundation of modern AI 38. cocoindex — engine for long horizon agents 39. freeCodeCamp — learn to code for free 40. stable-diffusion-webui — run image AI locally Most developers bookmark zero of these. The smart ones bookmark all 40.
- 12
@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.
- 13
@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
- 14
@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.
- 15
@gregisenberg ·
a post called "the west forgot how to code" is going viral among devs. the thesis: AI assisted devs ship faster but understand nothing. the next generation will be illiterate at the layer that matters. tbh, this panic happens every single decade. - assembly devs said C devs were illiterate. - C devs said java devs were illiterate. - java devs said react devs were illiterate. - react devs said no-code builders were illiterate. every single one of them was correct. every single one of them was also irrelevant within 10 years. the pattern is always the same. the new generation abstracts away the thing the old generation spent a career mastering. the old generation calls it dangerous. the new generation ships 10x faster & doesn't care. the market rewards speed. the cycle repeats. what's interesting is that the "illiterate" generation always wins. they win because they ship faster, build with less ego, & don't carry the baggage of what code is supposed to look like. they haven't been taught what's "proper." so they just build what works. the mass commoditization of coding is the mass democratization of building. the thing that used to take a team of 10 and $2 million now takes one person and a weekend. this means more competition. but it also means more weird, specific, niche products that never would have existed because the cost to build was too high. a million micro-products serving a million micro-audiences. the entire long tail of software just got unlocked. the people writing these posts are mourning a world where knowing how to code was a moat. it was. for decades. knowing how to code meant you had leverage that most people didn't have. that leverage is evaporating and it's uncomfortable. and I get it. I studied computer science at university. but the thing that replaced it is way more interesting. the new leverage is knowing what to build, who to build it for, and how to get it in front of them. that's harder to learn from a tutorial. that's harder to automate. & that's where the real compounding happens. the real question is "what happens when 100x more people can build" and the answer is a lot of garbage and a few things that change everything. that's always the answer. that was the answer with blogs, with youtube, with podcasts, with mobile apps. the gatekeepers always mourn the gate. that's terrifying if your identity is "I am a coder." it's the greatest opportunity in history if your identity is "I build things people want." okay, i had too much coffee. back to building.
- 16
@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.
- 17
@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
- 18
@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
- 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
@carlhua ·
i used to write flight software - you know, the one that flies jets and spacecrafts.. and if I had claude/codex back in the day, i wouldnt even need to look at code. hear me out, people say AI slop this, AI slop that, and the code it generated is trash etc etc. the thing is, with a highly tightened coding standard, and a requirement traceability down to say ~30-50 lines of code per requirement, you almost no longer need to look at the code it produced before doing testing. 2022 - oh wow, AI can write some code in the chat app 2023-2024 - cursor is amazing - it can write some code and understands the context 2025- the code is getting better and better, but often with mistakes 2026 - given the right guideline and specs, it is an EXPECTATION that the code should work the first or second round. I foresee in the near future, we would have IDE that no longer prioritizes displaying code. instead the IDE would be a tool to orchestrate agents, with responses gathering and display, so like an agent command center. I already see people building some of this but i think people are thinking about it wrong - don't take IDE or terminal as a baseline, we need to completely revamp it. This excites me because for once, we are going to revolutionize how coding is done. wait.. its not coding anymore, its more general than that, but you get the point! the subagent framework today is largely inadequate - we need a layer of LLMs on top of analyzing agents and then allow humans to control. but not all subagents should report back to the same upper LLM. whos building this? I will invest.
- 22
@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.
- 23
@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
- 24
@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.
- 25
@SergioRocks ·
Software development tools changed more in 18 months than in the previous 10 years. From 2014 to 2024, the toolbox was stable. - Jira for planning - GitHub for code - VS Code for editing - CI/CD for shipping The improvements were incremental. Better linters. Faster pipelines. Sleeker frameworks. Nicer UI. Now look at that chart. - Claude Code exploding. - Copilot everywhere. - Cursor rising fast. - A long tail of tools climbing behind them. And new ones popping up every week. This is not "just another tool". It's a whole new layer. The modern stack now includes: - AI pair programmers - Agentic coding workflows - Spec-driven markdown files - Context orchestration between repo and model - Token budgets and inference costs We used to budget for seats. Now we budget for tokens. We used to optimize for sprint velocity. Now we optimize for context quality. Teams that treat AI as “just another tool” will see marginal gains. Teams that redesign their process around it will see structural change. If your team's workflow still looks like 2022, the problem is not your engineers. It is your engineering process.
- 26
@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
- 27
@milan_milanovic ·
𝗪𝗵𝗮𝘁 𝗶𝘀 𝘁𝗵𝗲 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝗯𝗲𝘁𝘄𝗲𝗲𝗻 𝗺𝗮𝗻𝘂𝗮𝗹, 𝘃𝗶𝗯𝗲, 𝗮𝗻𝗱 𝗮𝗴𝗲𝗻𝘁𝗶𝗰 𝗰𝗼𝗱𝗶𝗻𝗴? A long time ago, we coded only manually, but then we started to vibe code. Yet, vibe code is something everyone defines differently. The question is, can we take the best from both worlds and make something more useful? The answer is yes, and this is 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴. Here is how they differ: 𝟭. 𝗠𝗮𝗻𝘂𝗮𝗹 𝗰𝗼𝗱𝗶𝗻𝗴 It means you write every line and understand every decision. Nothing is a black box. The bottleneck is your keyboard, which means it scales to exactly one engineer. For safety-critical systems where every line carries liability, it remains the right call. Everywhere else, it is too slow. 𝟮. 𝗩𝗶𝗯𝗲 𝗰𝗼𝗱𝗶𝗻𝗴 This represents the overcorrection. You describe what you want, the AI decides the implementation, and you ship it. It feels fast at first. Then something breaks, and you are debugging code nobody on your team wrote or reviewed. Many vibe-coded apps shipped with hype but also had security flaws and even more technical debt, which their authors didn't understand. This is a very good example of a Dunning-Kruger effect. Unfortunately, many non-coders are in this group. 𝟯. 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 Here, you write a PRD before any code is written. Here, you may have a few iterations of back-and-forth with the agent. Then, the agent implements, opens PRs, and runs tests. You review the output and enforce architecture rules in code. The bottleneck shifts from writing speed to the quality of your own decisions. I expect that we push more and more in this direction, recognizing good patterns and best practices, as we did with manual coding. These three coding approaches are a progression, and most teams are stuck in the middle one, thinking they have already arrived. Which one describes how your team works today?
- 28
@techNmak ·
The fastest coding agent in the world is still slow if ten tasks are standing behind it in a queue. Parallel Code removes the queue. I think the more interesting shift in AI coding is from chatting with one model to scheduling work against a repository. A bug fix, a test suite, a dependency upgrade, a refactor and an experimental implementation often have very few dependencies between them. There is no fundamental reason to serialize all five through one terminal. Parallel Code maps the problem onto primitives Git already understands: > branch = task > worktree = isolated filesystem > agent session = worker > diff = result > merge = selection Create a task and it creates a new branch, spins up a separate Git worktree, links ignored directories such as node_modules, and launches the coding agent inside that workspace. Several tasks can now progress without editing the same working files. When they finish, you inspect the diffs, leave comments, merge the useful branches and discard the rest. There is also an Arena mode for running competing implementations and comparing the results. Importantly, Parallel Code did not invent parallel coding agents. Claude Code already supports isolated worktree sessions. Codex also has built-in parallel agents, diff review and worktree isolation. That actually makes this repo more interesting, not less. It takes a pattern that is quickly becoming native across coding tools and exposes it as a free, open-source control surface for several existing CLIs. The point is not that you need Claude, Codex and Gemini simultaneously. The point is that task isolation should be independent of whichever agent you prefer. This feels less like pair programming and more like an operating system: > Fan out the work. > Isolate the processes. > Inspect the outputs. > Commit the good state. Models made individual coding tasks faster. Now the workflow around them is learning to become parallel. Here's the GitHub repo: https://t.co/sss4ImCEr7
Watch video
- 29
- 30
@smratitiwa86867 ·
Developers are quietly building a second brain inside their AI coding tools right now. And almost nobody realizes how important this shift is. Claude Code’s "Skills.md" looks like “just another markdown file.” It’s not. It’s the beginning of programmable AI memory for software engineering. Most AI coding workflows today are broken in the same way: • repetitive prompting • inconsistent outputs • forgotten context • unstable architecture decisions • AI behaving differently every session So developers waste hours re-explaining: “use this stack” “follow this pattern” “don’t break this API” “write code this way” Over and over again. "Skills.md" changes that completely. Instead of prompting the AI every time… You teach it how your team builds once. Now Claude starts operating with: - coding standards - architecture rules - debugging workflows - testing systems - project conventions - review patterns - deployment logic persisted directly into its workflow. That’s a massive shift. Because this is where AI stops feeling like autocomplete… and starts feeling like infrastructure. The real breakthrough in AI coding isn’t smarter models anymore. It’s persistent operational context. The teams moving fastest right now are not the ones writing better prompts. They’re the ones building reusable intelligence layers around AI. That compounds. Fast. And the scary part? Most developers still haven’t noticed this transition happening. They’re benchmarking models. Meanwhile advanced teams are quietly building internal AI operating systems around their workflows. That gap is going to become enormous. "Skills.md" is interesting because it represents something much bigger than Claude Code itself: AI that adapts to YOUR engineering system instead of forcing engineers to adapt to the AI. That changes: • onboarding • consistency • code quality • iteration speed • institutional memory • engineering velocity A lot of people will look back at these “simple markdown skill files” the same way we now look at: - Dockerfiles - package.json - .gitignore - tsconfig Small files. Huge workflow shift. The future of AI coding won’t belong to the people with the longest prompts. It’ll belong to the people who build the best AI environments. And that transition has already started.
- 31
@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.
- 32
- 33
@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
- 34
@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.
- 35
@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.
- 36
@andrewchen ·
why are spreadsheets the GOAT of no code tools? - unintimidating interface, just type numbers in a grid - easy to make something useful - shareable with a link - copy and make your own - insanely deep use cases (as a database, CRM, forecasting tools, etc) - finance team loves it, and they approve the budgets lol how many of these translate to agentic coding tools? - it's chat, could the UI be simpler? - you can build one-shot apps easily - insanely deep - share the output with a link - finance loves it as it gives more leverage and will cut SaaS costs There's more to do, but history rhymes. It has to be easier to share the code (not just the output), better management of forks, and more demonstration of operating leverage. But it's so powerful that it's inevitable agentic coding spreads as wall-to-wall as spreadsheets have And as I argued before, agentically coded apps I think will ultimately subsume spreadsheets completely. Maybe some will still want a grid UI, but underneath will be agentically created code
- 37
@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
- 38
@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...
- 39
@Suryanshti777 ·
The developers getting the best results from Claude Code aren't using better prompts. They're giving the model an operating systeml. This CLAUDE.md file is one of the best examples I've seen. Inspired by Andrej Karpathy's observations on LLM coding failures, it teaches Claude Code to: • ask questions instead of making assumptions • avoid overengineering and unnecessary abstractions • change only what's necessary • work toward verifiable success criteria In other words: You're not prompting the AI. You're defining its behavior. This is a much bigger shift than most people realize. We're moving from: > "AI writes code." to: > "Engineers design the rules that govern how AI writes code." The difference is massive. One approach produces messy PRs, random refactors, and bloated architectures. The other produces code that actually feels like it came from a senior engineer. I think CLAUDE.md, AGENTS.md, skills, and behavioral instructions are becoming a new layer of the software stack: • Source code • Tests • Infrastructure • Agent behavior The next generation of developers won't just write software. They'll engineer the engineers. And increasingly, those engineers will be AI agents. Open source, one markdown file, and a glimpse into where software engineering is heading. 🚀 https://t.co/QgItnv3zpf
- 40
@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 !
- 41
@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.
- 42
- 43
@Layton_Gott ·
Being a good developer can actually make you worse with coding agents at first. Because you treat the agent like a worse version of yourself. You expect it to infer the obvious You interrupt too early You patch things manually before the loop finishes You give it “just fix this” tasks instead of designing the workflow Then you blame the model when it loses the plot. But agent coding is a different skill. The best operators know how to: • split work into clean chunks • give the agent a narrow lane • force checkpoints before big changes • review diffs fast • use one model to challenge another • stop the agent before it digs deeper • turn repeated failures into repo rules That is why some non-cracked devs can get insane leverage from AI while better coders still hate it. Coding skill helps you judge the output. Agent skill helps you get better output in the first place. The devs who learn both are going to be the most powerful. Stop gatekeeping and give it a try... a real try.
- 44
@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.
- 45
@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
- 46
@AllurePixel ·
Collins named "vibe coding" Word of the Year I've been doing it for 1 months with zero coding background Here's what nobody tells you 41% of all code written in 2026 is AI-generated MIT called it a top 10 breakthrough technology 63% of vibe coding users are non-developers Sounds like the future arrived and it's easy It's not I'm building a full-stack web app from scratch Next.js, Supabase, real-time charts, gamification engine, 6 content modules, auth system, the works My dev environment is a $10/month VPS, Cursor, and Claude Code in a terminal I don't know what a hook is I still google what DNS means sometimes It works Not perfectly, not easily, but it works I went from literally not knowing what a terminal is to having a working app with 27 completed development phases, real users coming soon, and a Product Hunt launch in the pipeline The era of "just have an idea" is here
- 47
@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 🧵
- 48
@pascal_bornet ·
Being a developer in 2026 may look like scrolling your phone while AI writes the code. But that is not the real job. The real job is knowing whether the code should exist at all. This is the funny part of the AI coding era: AI can generate nonstop. Functions. Tests. Docs. Fixes. More fixes for the fixes. Meanwhile, the human looks “relaxed.” But the best developers will not be paid for typing every line. They will be paid for judgment. → What problem are we solving? → Is this architecture right? → Is the output secure? → What breaks at scale? → What should not be automated? For me, this is the shift leaders need to understand: 𝗖𝗼𝗱𝗶𝗻𝗴 𝗶𝘀 𝗺𝗼𝘃𝗶𝗻𝗴 𝗳𝗿𝗼𝗺 𝘄𝗿𝗶𝘁𝗶𝗻𝗴 𝗲𝘃𝗲𝗿𝘆 𝗹𝗶𝗻𝗲 𝘁𝗼 𝗱𝗶𝗿𝗲𝗰𝘁𝗶𝗻𝗴 𝘁𝗵𝗲 𝘀𝘆𝘀𝘁𝗲𝗺. That does not make developers obsolete. It makes weak developers exposed. Because if AI can write the first draft, the value moves to reviewing, testing, designing, deciding, and taking responsibility for what ships. The future developer may type less. But they will need to think more. And yes, maybe scroll a little while the agent works. 😅 𝗪𝗵𝗮𝘁 𝘀𝗸𝗶𝗹𝗹 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 𝗺𝗼𝘀𝘁 𝗶𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝘁 𝘄𝗵𝗲𝗻 𝗔𝗜 𝗰𝗮𝗻 𝘄𝗿𝗶𝘁𝗲 𝗰𝗼𝗱𝗲 𝗳𝗼𝗿 𝘂𝘀? #ArtificialIntelligence #AI #SoftwareEngineering #FutureOfWork #Developers #Coding #Automation #Leadership #HumanCenteredAI #DigitalTransformation
Watch video
- 49
@ttunguz ·
The $20/Month Software Revolution Software development has operated within established boundaries for decades, with clear divisions between those who code & those who don’t. But what happens when those boundaries dissolve overnight, & anyone can build functional applications for the price of a monthly streaming subscription? For twenty years, professional software development meant specialized teams, lengthy sprints, & rigorous adherence to architectural best practices. Companies invested months in planning, weeks in development cycles, & substantial resources in quality assurance. The barrier to entry remained high, protecting established players & maintaining predictable market dynamics. AI coding tools have shattered this equilibrium. Cursor, Lovable, & similar platforms now enable non-technical founders to prototype working applications in hours rather than months. The result is an explosion of vibe coding: intuitive, rapid application development that bypasses traditional workflows entirely. This shift has created a fascinating paradox for founders & investors. The current landscape rewards speed over sophistication, with spaghetti-coded solutions often outpacing polished alternatives to users’ laptops. Yet this same accessibility threatens to commoditize software development itself, raising questions about where sustainable competitive advantages will emerge. The answer lies in recognizing this period as history’s largest distributed market research experiment. Thousands of individual users are discovering optimal AI-enhanced workflows through trial & error, essentially crowdsourcing the future of software development. Smart players should treat this chaos as intelligence gathering rather than noise. The strategic opportunity exists in two phases. First, embrace experimentation during this chaotic period because the cost is minimal, & the learning is invaluable. Second, prepare for consolidation by identifying workflow patterns that demonstrate real user adoption & commercial viability. The current vibe-coding era won’t last forever. Eventually, brilliant practitioners in each domain will distill optimal workflows from this experimentation, commercialize them, & establish new industry standards. The companies that recognize these emerging patterns earliest & build robust, scalable versions before the market standardizes will define the next generation of software development tools. The glee of solving problems with $20-per-month AI tools represents more than convenience; it signals a fundamental restructuring of how software gets built & who gets to build it.
Watch video
- 50
@anulagarwal ·
i uninstalled all IDEs/code editors from my system earlier this year. not because i became a better developer. because the models and agentic coding tools became too good i don’t really read the code anymore -> i just prompt, wait, test, complain, iterate. this works for almost any digital product you want to build: apps, games, websites, tools. in most cases, i create a base template with 75% of the features already built, so i don’t have to prompt and test the same things again and again. the funny part is, i used to think coding was the hard part. now the hard part is explaining exactly what i want without sounding like a client from hell. sometimes, you are not the developer anymore. you are just the QA intern for a very confident robot.
Best Tweets by Topic