Explore the best tweets about AI coding, coding agents, AI developer tools, software workflows, and production lessons. Updated every two weeks.
Code-first examples showing where AI improves software work, where it fails, and how experienced developers use it.
Original Xholic analysis
Across 50 posts from 42 creators on AI coding, the conversation splits into a practitioner playbook and a cautionary ledger. Practitioners converge on workflow engineering: small tasks, fresh sessions, instruction files like CLAUDE.md/AGENTS.md, reusable skill libraries, and multi-agent orchestration with verification gates. Cautionary posts cite an Anthropic skill-formation study and NBER research on the gap between 17x code output and a ~30% release uplift, warning that vibe coding atrophies debugging and comprehension. The dominant theme, per an 18%-share theme and multiple posts: AI writes code; engineers still have to understand systems.
48% of posts
All-time engagement
52% of posts
Published in 90 days
Conversation map
The shift from writing code to directing it: senior judgment, systems thinking, delegation boundaries (safe / collaborative / human-owned zones), reviewing agent transcripts, and 'engineers understand systems, AI writes code'
18%
Hands-on advice lists: break tasks small, state do-not sections, fresh thread per feature, read the tests AI wrote, three failed fixes means reset; plus stage-of-adoption models (distrust โ full delegation โ slop โ balance)
18%
Making codebases legible to agents via CLAUDE.md / AGENTS.md, context-clash avoidance, one-task-per-session hygiene, and knowledge-graph tools like Graphify that replace repeated grep with persistent queryable maps
18%
Splitting coding work across specialized agents with orchestrators, retry loops, approval gates, and 'software factory' pipelines; the idea that workflow design, not model intelligence, is the real leverage (chief-of-staff pattern, /factory
14%
Shareable skill libraries and command sets (/spec, /plan, /build, /test, /review, /ship) that impose senior-engineer discipline on agents; anti-rationalization tables, skill marketplaces, portable markdown workflows across Claude Code, Codx
12%
Warnings that vibe coding atrophies understanding and debugging ability, creates a gap between what the system does and what the developer can explain, and that supervision requires the very skills AI usage erodes
12%
Research findings on real output vs. hype: NBER's 17x code vs. 30% release uplift, Anthropic's skill-formation paper, CMU velocity decay, benchmark footnotes (50% success rates), and the gap between typed lines and shipped value
4%
Agents can't grade their own homework: independent reviewer agents, CI verification loops, preemptive constraints (guideโverifyโsolve), spec-first specs to reduce rewrites, and multi-layer zero-trust checking
4%
Tone and stance
Performance benchmark
Posts with media make up 64% of this collection. Their median all-time score is 28.9, compared with 9.01 for text-only posts.
Format mix
Consensus and debate
Shared view
The judgment-over-typing theme (18% share) is the most broadly echoed idea: AI coding agents are easy to learn in days, but knowing what to ask for and when code is brittle or insecure takes decades (2062149801563857346). Related posts argue the developer's job shifts from writing lines to directing the system (2055936619631513890), that agents make junior engineering nearly impossible while taxing senior judgment (5
Shared view
Across themes totaling a large share of posts, the consistent claim is that leverage comes from the system around the agent: instruction files that encode repo structure and conventions (2053919554234106266), one-task-per-session hygiene to avoid context clash (2062557490282197190), persistent codebase knowledge graphs instead of repeated searching (2114313618611220950), and orchestration patterns like the chief-of-
Shared view
Verification with fresh eyes recurs across otherwise different posts: a 'software factory' pipeline that has a never-before-seen agent review the builder's output (2081031938228232360), an open-source workflow where a clean-memory reviewer returns ship/fix/rethink verdicts (2090444100256534997), and multi-layer zero-trust checking with separate guide/verify/solve loops (2083548760295043260).
Open debate
One camp champions autonomy: a /goal meta-prompting workflow that lets an agent 'work for days without stopping' (2051525926874501291) and an overnight /factory assembly line with circuit breakers (2081031938228232360). The other camp calls this dangerous for most people: one top-voice creator argues AI coding loops are 'horrible advice' for 99% of people, who should instead work closely with the agent on the next-sm
Open debate
Posts clash on productivity. One claims scaling-grade apps still need mostly manual orchestration, with AI writing only boilerplate for a 10โ20% speed gain (2088168368125686093). A contrasting post reports a team getting far more than the '~10% productivity boost' many developers see, by reframing how they use the tools (1932452792033263657). NBER-based posts split the difference: 17.3x more code typed, but only ~30%
Open debate
One post, citing Anthropic's 2026 Agentic Coding Report, argues developers fully delegate only 0โ20% of tasks and that keeping architecture, security, and critical decisions human-owned is professional judgment (2039992146552639808). Another predicts the winning systems will own the entire buildโtestโdebugโreviewโship loop 'with increasingly little human intervention' (2075686635619180958).
What performs
The top outlier is a 24-tool vibe-coding mega-thread at 228.7x the median all-time score (4494.21 vs 19.65 median), followed by the /factory software-factory tutorial at 199.1x. The TUTORIAL format's median all-time score (302.3) dwarfs LIST (63.7) and OPINION (8.8), despite tutorials being only 10% of posts.
The open-source skills theme has the highest median all-time score (229.84) of any theme, vs 8.9 for skill-erosion warnings. Readers engage far more with plug-and-play discipline (Agent Skills with anti-rationalization tables, /specโ/ship command sets) than with warnings that AI erodes debugging ability.
64% of posts include media, and media posts have a 28.92 median all-time score vs 9.01 for text. Stance is 64% supportive vs 36% cautionary, and sentiment runs 48% positive / 26% neutral / 16% negative / 10% mixed. The conversation skews evergreen: only 20% of posts are within 90 days (median age ~148 days).
Statistical standouts
Creator landscape
The five most represented creators account for 20% of the selected posts.
1. Alex Finn
@AlexFinn
2 posts
2. divyansh tiwari
@DivyanshT91162
2 posts
3. Howie Xu
@H0wie_Xu
2 posts
4. John Crickett
@johncrickett
2 posts
5. Layton Gott
@Layton_Gott
2 posts
6. smrati tiwari
@smratitiwa86867
2 posts
The most engaged posts argue leverage comes from the system around the agent, not the model: a '/factory' pipeline with planning, testing, and fresh-eyes review (2081031938228232360), and a chief-of-staff orchestrator that isolates context per sub-agent โ though its author notes he personally sticks to a single Claude Code session (2102388569449140316). The TUTORIAL format's 302.3 median all-time score and the top-2
The judgment-over-typing theme (18% share) argues AI agents are easy to learn but hard to use well: the hard part is knowing what to ask for and when code is brittle or insecure (2062149801563857346). Delegation-zone frameworks split work into safe, collaborative, and human-owned categories (2039992146552639808), and one PM warns agents make junior engineering nearly impossible while taxing senior judgment on every
The 18%-share repo-context theme holds that agents underperform when starved of repo context rather than because of model limits. Graphify maps codebases into persistent queryable graphs so agents stop re-searching the same files (2114313618611220950), AGENTS.md/CLAUDE.md files encode where files live and what 'done' means (2053919554234106266), and one-task-per-session hygiene avoids context clash (2062557490282
Since the previous snapshot
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 AI Coding tweets
Ranked 01โ50
@johnrush ยท
I've tried all (24) AI coding agents & IDEs ๐ตโ๐ซ [Cursor, Softgen, Windsurf, Wrapifai, Copilot, Lovable, Bolt, v0, Replit, MarsX, Claude, AmazonQ, Pear, Devin, Github Spark, IDX, Webdraw, Tempo, Cline, Continue, Databutton, Base44, Qodo, Aider] The Vibe Coding giga-thread:
@mfishbein ยท
This is my personal software factory. It turns ideas into working products while I sleep. No babysitting coding agents with prompts all day. Cursor and Claude Code made writing code way easier. The harder problem is building a system that can context engineer and manage itself. My factory starts with a Skill called `/factory`. It's the foreman that remembers where the project stands and sends in the right worker for the job. Factory runs this assembly line: 1. `/factory-plan` - the interviewer Reads the existing codebase (if there is one), extracts missing context from me via interview, and writes a product brief. 2. `/factory-plan` - the planner The same skill turns the approved brief into small, testable features and development tasks. 3. `/factory-tests` - the professor Before anyone writes code, every task gets an exam. This skill defines the success criteria for each task, and how the coding agent can prove to itself that what it built works or needs iteration. 4. `/factory-explain` - the presenter Explains the plan to me like I'm 10, with visual metaphor and mermaid charts. Now that coding agents can write more code, faster than any human ever could, the new bottleneck is human understanding of the code. This skill solves that. 5. `/factory-handoff` - from CTO to SWE This packages the brief, plan, tests, safety rails, and stop conditions into one work order. Factory uses the best models for the planning in the previous steps above, then hands the work order to a lower token usage model like Grok 4.5 for execution. 6. Cursor or Claude Code `/loop` - the coffee The night shift picks one task, builds it, takes its exam, records what happened, iterates if needed, then moves onto the next task. If it gets stuck, circuit breakers stop it from confidently digging a deeper hole while I sleep. 7. `/factory-review` - the teacher grades the homework The student doesn't grade it's own homework. A fresh agent that never met the builder tries to break the result. The reviewer rereads the original plan, reruns tests, and finds anything that's broken. 8. `/auto-loom-proof` - shows the evidence Uses browser use and screen records itself performing the tests and adds an 11labs voiceover explaining what's being proven. It sends me the narrated demo video. 9. `/factory-explain` - the code The factory updates a plain-language owner's manual explaining what actually got built. I understand my own codebase, so I can make decisions without becoming the bottleneck or outsourcing my thinking to AI. NOTE ON BUILDING AI Cursor and Claude Code have made writing code dramatically easier. But getting AI to work reliably and at scale for you can't be fully automated. LLM-as-judge helps, but a judge needs a rubric, examples, and input from someone with subject matter expertise. You still need a human reviewing the work and teaching the system how to perform better. You can check out my factory on github in the post below.
@techNmak ยท
A 135K-star GitHub repo is built around one painfully obvious idea: Your coding agent should map the codebase once, not grep it forever. Graphify turns an entire project into a persistent, queryable knowledge graph that AI coding agents can use to understand how different parts of the system connect. Functions, classes, files, SQL schemas, infrastructure configurations, documentation, PDFs, images and videos can become connected nodes instead of isolated pieces of context the agent has to rediscover. So instead of: โ Search for authentication โ Open twelve files โ Follow imports and function calls โ Lose the trail as the context fills up The agent can ask: > What connects authentication to the database? > Trace the path from UserService to DatabasePool. > Explain RateLimiter. > Which components are central to this architecture? Graphify returns relevant graph relationships and paths, rather than another collection of keyword matches. For source code, the implementation is particularly interesting. It uses tree-sitter to parse approximately 40 programming languages locally, extracting functions, classes, imports, calls, inheritance and cross-file relationships. No embeddings, vector database or LLM calls are needed to construct the code graph. Document and media processing works differently. PDFs, images and other non-code content can go through an optional semantic extraction step using a configured model. Every relationship carries a confidence label: โ EXTRACTED: Explicitly present in the source โ INFERRED: Derived through analysis or resolution โ AMBIGUOUS: Uncertain and flagged for review Graphify also uses community detection to identify related subsystems and highlights highly connected nodes that may be important to the overall architecture. But the part that makes this useful for coding agents is what happens after the graph is built. Graphify integrates with Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot and more than 20 other assistants. Depending on the platform, it installs hooks or persistent instructions that encourage the agent to query the existing graph before repeatedly searching and reading source files. The graph can be committed to Git, updated incrementally as files change, and exposed through MCP. There's also support for examining pull requests against the graph, including identifying PRs that touch related graph communities and may need closer review. The local tool produces three useful artifacts: an interactive HTML graph, a Markdown architecture report and a reusable graph.json. Long context windows help coding agents read more code. A persistent knowledge graph gives them a way to navigate what they've already analyzed. And as coding agents spend more time working inside large repositories, avoiding repeated discovery of the same architecture becomes increasingly useful. Here's the GitHub Repo: https://t.co/4ify3X7WBR
@AlexFinn ยท
The biggest advancement in AI coding this year has been /goal And it isn't even close It allows your AI agent to quite literally work for days without stopping. You give a mission. It works until the mission is complete Here's the thing though: /goal is useless if you don't use it properly You NEED a good prompt for it I found basically any prompt I hand write after /goal is never good enough. It produces results that might as well have been a normal prompt Meta prompting is the answer Go to any AI that has context around the project you're working on Say "I'm working with Codex and I want to use their new /goal feature. Please research their /goal feature. Then, take a look at our project and give me 3 options for how we could use /goal to be maximally productive. Then give me a highly detailed /goal prompt for each" Take one of the prompts then go into the Codex CLI and type /goal then give the new prompt I 100% guarantee the AI does better work than you've ever seen before
@heygurisingh ยท
Holy shit... Addy Osmani just dropped something that will make "Vibe Coders" loose their mind. It's called Agent Skills. Production-grade engineering workflows that force AI coding agents to actually behave like senior engineers, not interns shipping prototypes to prod. โ Spec before code (no more "what are we even building") โ Plan-mode task breakdown into verifiable chunks โ Incremental implementation in thin vertical slices โ TDD with the Prove-It pattern (reproduce bugs as failing tests first) โ Chrome DevTools MCP so the agent has real eyes in the browser โ 5-axis code review (correctness, readability, architecture, security, perf) โ OWASP-aware security hardening โ Git workflow, CI/CD gates, ADRs, staged rollouts No more shortcuts. No more skipped tests. No more "seems right, ship it." Every skill has verification steps and an anti-rationalization table. Yes, an actual table of the excuses agents use to skip steps ("I'll add tests later") with documented rebuttals. The wildest part? It works with Claude Code, Cursor, Windsurf, Copilot, and Codex. Plain markdown. Plug it in anywhere. This is the gap between AI that writes code and AI that ships software. 100% Open Source. MIT licensed. (Link in the comments)
@sharbel ยท
Someone built a free collection of production-grade engineering skills that teaches your AI coding agent to work exactly like a senior engineer. It's called agent-skills. 60,800+ stars on GitHub. You drop it into Claude Code, Codex, Cursor, or Gemini CLI. Here's what it does: โ `/spec` forces the agent to define what to build before touching code. Spec before code. Every time. โ `/plan` breaks the spec into small, atomic tasks. No giant PRs. No mystery diffs. โ `/build` implements one slice at a time. Each task is test-driven and committed individually. โ `/build auto` generates the plan and runs every task in a single approved pass. You approve once. It executes autonomously. Pauses on failures or risky steps. โ `/test` proves the code works. Tests are treated as proof, not afterthought. โ `/review` enforces code health before merge. A real quality gate, not a vibe check. โ `/code-simplify` rewrites for clarity over cleverness. Kills the clever nonsense your agent wrote at 2am. โ `/ship` runs the full production checklist. Faster is safer only when nothing is skipped. โ Skills activate automatically based on context. Building an API triggers `api-and-interface-design`. Building UI triggers `frontend-ui-engineering`. No manual configuration. 100% Open Source. Github repo link: https://t.co/DUlNIoUr7u
@pvergadia ยท
JUST DROPPED: Anthropic's research proves AI coding tools are secretly making developers worse. "AI use impairs conceptual understanding, code reading, and debugging without delivering significant efficiency gains." -- That's the paper's actual conclusion. 17% score drop learning new libraries with AI. Sub-40% scores when AI wrote everything. 0 measurable speed improvement. โ Prompting replaces thinking, not just typing โ Comprehension gaps compound โ you ship code you can't debug โ The productivity illusion hides until something breaks in prod Here's why this changes everything: Speed metrics look fine on a dashboard. Understanding gaps don't show up until a critical failur and when they do the whole team is lost. Forcing AI adoption for "10x output" is a slow-burning technical debt nobody is measuring. Full paper: https://t.co/JeRZr6up6P
@Suryanshti777 ยท
179k GitHub stars. An ex-Vercel engineer just open-sourced the exact AI coding workflow he uses every day. Not prompts. Not templates. A complete .claude setup with 26 production-ready skills you can clone for free. Here's what stood out: โข grill-with-docs โ Interviews you before writing the implementation plan โข code-review โ Reviews architecture, not just syntax โข diagnosing-bugs โ Runs a systematic debugging workflow instead of random guessing โข research โ Investigates primary sources before making changes โข grill-me โ Challenges your thinking until the plan has no weak spots โข handoff โ Compresses an entire coding session into a clean handoff for the next agent โข writing-great-skills โ Helps you create reusable AI skills that actually work The best part? These aren't tied to Claude. The workflows can be adapted to Cursor, Codex, Gemini CLI, OpenAI, Amp, Windsurf, or practically any coding agent. If you're building with AI in 2026, the advantage isn't having a smarter model. It's having better workflows. This repo is basically a free masterclass in how senior engineers collaborate with AI. Worth studying even if you never copy a single file. ๐ Bookmark this before it disappears from your timeline. What's your favorite AI coding agent right now?
@arpit_bhayani ยท
One of the design patterns showing up in AI coding assistants and headless agentic SDLC (suited to work at scale) right now is the "chief of staff" pattern. Here's what it is... The idea is simple and classic. Instead of one large agent trying to plan, write code, review it, and manage its own context all at once, you split the work. A top-level orchestrator agent, the "chief of staff," never touches the codebase directly. Its only job is to break the task down, delegate pieces to specialized sub-agents, and stitch the results back together. This matters because of a very practical constraint -- context windows. The classic reason why one should use sub-agents/multi-agents. A single agent working end-to-end on a large task accumulates tool outputs, file reads, and failed attempts, and all of that stays in its context. Eventually the model is reasoning with a context window full of noise, and quality drops even though the task has not gotten harder. The chief of staff pattern fixes this by isolating context per sub-agent. A "coder" sub-agent gets a narrow, well-scoped instruction and a clean context. It does its work, returns a result, and, more importantly, its full trace. The orchestrator then only keeps the summary in the context. Here are a few concrete roles you will see split out this way: - planner - reads the codebase and produces a task breakdown. - coder - implements one scoped change. - reviewer - checks the diff against the original intent, catches regressions - test-runner - executes and interprets test output. The orchestrator is not coding at all; it is delegating and synthesizing: deciding what to hand off, what context each sub-agent actually needs (not everything, just enough), and how to reconcile results that partially conflict. This also gives you a natural retry boundary. If a sub-agent fails, you retry that sub-agent with a corrected instruction instead of restarting the whole task, since the failure and its context stay contained to that one delegated unit of work. By the way, all of this sounds theoretically very good, but I have personally not been using this directly :) Thought of sharing so that you are aware, but for me, one simple Claude Code session is good enough. But in case you are building an agentic SDLC (more specific - headless variant), this might be helpful, as it is a pretty solid way to scale agentic coding past what fits in one context window. Hope this helps.
@Sumanth_077 ยท
Microsoft open-sourced an AI Engineer Coach! AI Engineer Coach is a VS Code extension that reads your local AI coding session logs and turns them into actionable insights. Works with any harness - Claude Code, Copilot, Cursor, Codex, Cline. Everything runs on your machine. No data leaves. Most developers using AI coding tools don't know if they're actually getting better at using them. What prompts they repeat. What habits are slowing them down. What their context health looks like. This extension answers all of that. Four layers: 1. Observe - Practice scores with week-over-week trends, daily activity charts, Gantt-style session timeline, and a screenshot gallery from your coding sessions. 2. Measure - AI-generated code volume broken down by language, model, workspace, and harness. Activity heatmaps showing your 7ร24 coding patterns. 3. Improve - 45 anti-pattern rules across prompt quality, session hygiene, code review, tool mastery, and context management. Each rule comes with severity ratings and concrete actions. Skill Finder discovers repeated prompt patterns and matches them to reusable skills from the open-source catalog. Context Health runs agentic readiness checks and audits your instruction files. 4. Level Up - Personalized quizzes generated from your actual usage data. XP-based progression with Bronze to Diamond tiers. An Agentic SDLC view showing how you use AI across the full development lifecycle. Key capabilities: โข Works with any AI coding harness in one dashboard โข 45 anti-pattern detection rules across 5 categories โข Skill Finder for repeated prompts and reusable skills โข Context Health with agentic readiness checks โข Personalized quizzes from your actual session data โข All local - no data leaves your machine โข Editable rules with live testing via Rule Playground 100% open source. I've shared the link in the replies!
@AlexFinn ยท
Everyone on X talking about building AI coding loops I think for 99% of people it's horrible advice. Mostly being promoted by people who profit off token burn Unless you are deeply technical, you are going to build flimsy apps and burn outrageous amounts of money Engineering a loop that produces high quality code requires insane amounts of setup and oversight to make sure it's done the right way For a vast majority of people the best AI coding strategy is: 1. Work closely with your agent, ask it to build the next smallest people of functionality you can think of 2. After each small chunk, ask the AI what it did. Tell it to describe it to you concisely 3. If anything is too technical, ask it to explain in a non technical way so you deepen your knowledge 4. Have it continuously maintain a current state doc you can feed to another LLM to get 2nd perspectives on crucial decisions 5. Mute influencers who give you vague advice that doesn't really mean anything This will actually save more time in the long run because you won't have to untangle code you don't understand
@rohanpaul_ai ยท
Anthropic's own study proves Vibe-Coding and AI coding assistants harm skill building. "AI use impairs conceptual understanding, code reading, and debugging abilities, without delivering significant efficiency gains on average" Developers learning 1 new Python library scored 17% lower on tests when using AI. Delegating code generation to AI stops you from actually understanding the software. Using AI did not make the programmers statistically faster at completing tasks. Participants wasted time writing prompts instead of actually coding. Scores crashed below 40% when developers let AI write everything. Developers who only asked AI for simple concepts scored above 65%. Managers should not pressure engineers to use AI for endless productivity. Forcing top speed means workers lose the ability to debug systems later. ---- Paper Link โ arxiv. org/abs/2601.20245 Paper Title: "How AI Impacts Skill Formation"
@johncrickett ยท
โSoftware engineers who donโt know how to use AI coding agents will fall behind.โ No. AI coding agents are not the hard part of building software. Theyโre a simple tool. You can learn to use them in a few days. The hard part is knowing what to ask for. Knowing whether the answer is any good. Knowing when the code is brittle, overcomplicated, insecure, or just plain wrong. Itโs the judgement required to use them well. Thatโs software engineering. And that takes decades to learn properly. The people at risk arenโt engineers who havenโt mastered using coding agents yet. Itโs people who only know how to prompt one.
@akshay_pachaar ยท
Microsoft built a Fitbit for AI. they just open-sourced AI Engineer Coach. a VS Code extension (also works in Cursor and Antigravity) that analyzes how you actually use AI coding agents. it reads local session logs from GitHub Copilot, Claude Code, Codex CLI, OpenCode, and Xcode. one dashboard across every harness you use. it scores your workflow across five categories: prompt quality, session hygiene, code review, tool mastery, and context management. it ships with 45 anti-pattern detection rules. things like prompts with no file context, mega sessions that drift off-topic, auto-approving terminal commands without a devcontainer, and burning premium tokens on trivial questions. each finding shows what went wrong, how to fix it, and a real example from your own sessions. the rule engine is the interesting part. every detector is a markdown file with a small expression language, so you can tune thresholds, write new rules, or describe one in plain English and let Copilot scaffold it. there's also a Skill Finder that spots repeated prompt patterns and turns them into reusable skills. everything runs locally. read-only by design, zero telemetry. we've spent two years making AI agents faster. almost nobody is measuring how effectively developers actually work with them. AI Engineer Coach treats your AI workflow the way observability tools treat production systems. MIT licensed, fully open-source. link in the next tweet.
@HedgieMarkets ยท
๐ฆAn NBER study by MIT and Wharton researchers tracked 100,000 GitHub developers before and after adopting AI coding tools. Autonomous agents produced 17x more lines of code. But by the time that work went through review and release, the uplift shrank to 30%. When they checked four major app marketplaces, they found more new apps but no increase in total usage or downloads. More software shipped, but nobody used it. My Take The bottleneck in software has always been deciding what to build, reviewing whether it works, and convincing someone to use it. AI accelerated the typing and left all three of those untouched. The entire financial case for the AI buildout assumes faster output translates to more economic value. This study measured it and found that it mostly doesn't, at least not yet. Alphabet reports Wednesday with $180 billion in capex guidance. If the productivity gains from AI coding tools can't survive contact with the rest of the production chain, the revenue assumptions underneath that spending need to be a lot more conservative than what these companies are currently projecting. Hedgie๐ค
@VaibhavSisinty ยท
A Director at Google just open-sourced the exact engineering playbook their senior engineers follow. ๐คฏ It's called Agent Skills by Addy Osmani. 23 production-grade skills that teach AI coding agents to work like a senior engineer. Not generic prompts. Structured workflows with steps, quality gates, and verification at every stage. 7 commands that map to how real software gets built: โ /spec : define what to build before writing code โ /plan : break it into small atomic tasks โ /build : implement one slice at a time โ /test : prove it works with real evidence โ /review : five-axis code review before merge โ /code-simplify : clarity over cleverness โ /ship : deploy with confidence Every skill has an anti-rationalization table the excuses AI agents make to skip steps like "I'll add tests later" with documented counter-arguments built in. Works with Claude Code, Cursor, Gemini CLI, GitHub Copilot, Codex, and Windsurf. Based on Google's internal engineering practices. Free. MIT license.
@Hesamation ยท
this is 80% of all you need to know about AI coding. the rest is useful only if you follow these principles, which top engineers practiced even *before* AI. these are 8 fundamental tips on aimaxxing: > learn how to program first. AI is a multiplier of what you already know. > be as specific as possible. communication is an important skill in software now. > the smaller the tasks the better results. break down big problems to smaller ones. this is a basic engineering skill you must know anyways. > do not let AI do all the thinking for you. that makes you useless. > tell AI what you donโt want to avoid slop. put a do-not section in the prompt/markdown. > use markdown files for the agent so it remembers. > donโt sleep on MCPs. theyโre super easy to use by now. have a few necessary MCPs and donโt clutter it. > give AI a way to verify its work. CI/CD pipelines, test cases, etc. make it yourself or have the ai make it.
@emollick ยท
Big paper on AI coding agents using Github & other data The auto-complete tools (Copilot) led to 2.2x more code, local agents like original Claude Code led to 7.4x, & current remote coding agents 17.3x(!) But human bottlenecks in coding means actual releases "only" went up 30%
@RoundtableSpace ยท
Your AI coding agent could understand an entire codebase without reading every file Graphify turns code, docs, and other project files into a searchable knowledge graph, reportedly using 71.5x fewer tokens per query while running locally without embeddings or API costs. Stop paying your AI agent to rediscover the same codebase every session. Repo: https://t.co/qaZQ3CLibj
@pauliusztin_ ยท
The future of AI coding is NOT one super-agent. It's agent loops. One agent shouldn't: Plan Code Test Review Monitor CI Those are different jobs. My coding setup splits them across specialized agents, with bounded retry loops and only two human-approval gates. The biggest lesson? The quality of an AI software factory isn't determined by how smart your coding agent isโฆ It's determined by how well you engineer the workflow around it.
@GohilHardy ยท
The most frustrating thing about AI coding tools: they understand your codebase. they follow your patterns. they respect your instructions. and then, out of nowhere, they start inventing their own patterns.
@freeCodeCamp ยท
AI coding agents can move fast, but they can also make plausible assumptions you wouldn't approve. In this tutorial, @dannwaneri teaches you how to use spec-writer, a Claude Code skill he built. It turns a rough feature request into a spec, technical plan, and task breakdown so your agent guesses and rewrites less. https://t.co/LdqNMPsCYF
@Trader_XO ยท
Iโve been in the AI trenches for a few months now, and itโs never been more evident as to why clean code still matters, just as it did prior to agentic coding. Eg when Iโve set up a project the way any seasoned senior engineer would, with clear structure, solid conventions and defined boundaries, the codebase grows in a much healthier way. It sounds obvious, but AI makes the difference more extreme. AI does not fix weak structure or semantics, it builds on whatever is already there. What has worked well for me is keeping a clean directory structure from day one, building shared utilities such as consistent error handling, enforcing tight naming conventions, and defining clear rules for APIs and design patterns through lifecycle hooks - pre and post. When the foundations are in place, new features are โsimplerโ to roll out. When the basics are rushed, the problems scales just as quickly. Small inconsistencies turn into bigger ones. Technical debt builds faster than it used to, 1000 lines of code grows very quickly to 10000 lines of unstructured mess. Whatโs helped before building is having a common framework for using AI tools, because early structure matters more than ever. Code reviews need to be tighter, not looser. Moving fast and fixing later becomes more expensive. Senior engineers matter because they set the patterns the AI will copy. AI speeds up whatever direction you are heading from the base up.
@TechWithKhushi ยท
Most developers think Claude Code is just an AI coding assistant. They're wrong. Claude Code is secretly a 5-layer operating system for AI agents. And 90% of people never go beyond Layer 1. Here's the architecture ๐ โโโโโโโโโโโโโโโ ๐ง Layer 1 โ Memory (CLAUDE.md) Your project's brain. Stores: โ Coding standards โ Architecture decisions โ Team workflows โ Repo conventions โ Engineering rules Persistent across sessions. This is what transforms Claude from: "Generic AI" into: "Your engineering team's AI." โโโโโโโโโโโโโโโ ๐ Layer 2 โ Skills Reusable expertise modules. Need: โ A React expert? โ A security auditor? โ A database architect? Claude dynamically loads the right knowledge only when needed. Benefits: โ Cleaner context โ Lower token usage โ Specialized execution โ Fewer hallucinations This is where AI starts feeling agentic instead of conversational. โโโโโโโโโโโโโโโ ๐ Layer 3 โ Hooks The layer most teams completely ignore. Hooks are programmable infrastructure triggers. Examples: โ Auto-run tests โ Block risky commands โ Enforce code quality โ Inject runtime context โ Send Slack alerts โ Auto-format outputs This is NOT AI reasoning. It's deterministic reliability. Production-grade AI systems are built here. โโโโโโโโโโโโโโโ ๐ค Layer 4 โ Subagents This is where Claude Code becomes a true multi-agent system. Delegate tasks like a real engineering organization: โ One agent writes code โ One reviews PRs โ One writes tests โ One investigates bugs Parallel execution. Isolated context. Separate tools. No context pollution. No recursive chaos. You stop thinking: "One assistant" And start thinking: "Distributed cognitive workers." โโโโโโโโโโโโโโโ ๐ฆ Layer 5 โ Plugins The distribution layer. Package: โ Skills โ Hooks โ Commands โ Agents โ Workflows ...into one reusable install. Install once. Share across teams. Reuse everywhere. This is how organizations operationalize AI engineering at scale. โโโโโโโโโโโโโโโ The biggest misconception in AI right now: People think the magic is prompting. It's not. The real leverage comes from: โ Architecture โ Orchestration โ Memory systems โ Deterministic workflows โ Agent coordination Most people are chatting with Claude. A few are building autonomous software teams inside it. That's the real shift happening right now. ๐ Bookmark this if you're serious about AI engineering. #ClaudeCode #AIAgents #AgenticAI #AIEngineering #SoftwareDevelopment #LLM
@msnmongare ยท
Someone reached out to me recently "Bro, niaje. My payments on the system are showing duplicates whenever someone pays successfully" Then came the follow-up: "Someone on TikTok, a popular developer vibe-coded my app. I know he's your friend." That conversation got me thinking. Vibe Coding Ends in Production Agentic AI coding is incredibly powerful ๐ฅ You can describe an idea, and within minutes, an AI agent can generate a payment integration, API, database schema, authentication, webhooks, and an entire application. What I learnt is; The problem is not that AI-generated code cannot work. The problem is deploying code you don't fully understand, especially in domains where you lack the fundamentals. Moral lesson: ๐๐พ๐๐พ The more I use AI coding agents, the more convinced I become that software engineering fundamentals matter more than ever. AI can write code. Engineers understand systems.
@smratitiwa86867 ยท
Andrej Karpathy just explained the future of software engineering without directly saying it. The best AI engineers are no longer โprompting.โ Theyโre building systems around the agents. Karpathyโs biggest insight wasnโt: โClaude can code.โ It was: LLMs become dramatically better when you force them into disciplined workflows. Thatโs why "CLAUDE.md" files are suddenly everywhere. Not because theyโre prompts. Because they behave like an operating system for the agent. Karpathy called out the exact problems with AI coding: - models assume instead of asking - they overengineer simple tasks - they hide confusion - they rewrite unrelated code - they optimize for completion, not correctness So developers started encoding rules directly into the workflow: โ Think before coding โ Simplicity first โ Surgical edits only โ Goal-driven execution And the results are wild. People are now running multiple Claude Code agents in parallel like engineering teams: โข one agent researching โข one debugging โข one writing tests โข one optimizing code โข one validating outputs Not โAI assistance.โ Actual orchestration. And this part from Karpathy changes everything: โDonโt tell the model what to do. Give it success criteria and let it loop.โ That is the shift. From: โwrite this functionโ To: โhereโs the goal, constraints, tests, and verification system โ now iterate until correct.โ The craziest part? This already feels like a phase shift in engineering. A lot of developers quietly went from: 80% manual coding โ to 80% agent-driven coding in just months. Not because AI became perfect. Because the leverage became impossible to ignore. Weโre entering an era where the highest leverage engineers wonโt necessarily be the best coders. Theyโll be the people who build the best systems around AI agents.
@DivyanshT91162 ยท
The most valuable AI coding resource on GitHub isn't a framework. It isn't an agent. It isn't even code. It's a 65-line text file. The famous CLAUDE.md shared by became one of the most talked-about resources in the developer community because it solved a problem most people don't even realize they have: AI doesn't fail because it's dumb. It fails because the instructions are. Inside are 4 deceptively simple rules that dramatically improve coding accuracy: โข Think before coding. State assumptions. Ask questions. Never guess. โข Simplicity first. Write the minimum code required. No unnecessary abstractions. โข Make surgical changes. Don't touch unrelated code. Every edit must have a reason. โข Define success before writing code. Turn vague requests into measurable outcomes. That's it. No secret prompts. No agent framework. No 500-page guide. Just a system that forces AI to think like a disciplined engineer instead of a code-generating machine. Most developers are chasing bigger models. The smartest ones are improving how those models think. Save this. These 65 lines are worth more than thousands of AI tutorials. ๐
Watch video
@Shruti_0810 ยท
An 82Kโญ GitHub repo is built around one painfully obvious idea: AI coding agents waste more time **searching** your code than understanding it. Graphify maps the repo once into a queryable knowledge graph. So instead of: โ grep โ open 20 files โ lose context The agent asks one question... > "How does authentication reach the database?" ...and gets the exact path. No embeddings. No vector database. No LLM. The future of AI coding isn't bigger context windows. It's making agents stop reading the same files over and over. GitHub: https://t.co/ovZM6eWx6R
Watch video
@Layton_Gott ยท
The next big AI coding edge is NOT better prompts... Itโs making your repo easier for agents to understand. Devs throw Claude Code or Codex into a messy codebase and wonder why it makes weird decisions. But the agent is missing the same thing a new engineer would need: โ where the important files live โ how the app is structured โ what patterns to follow โ what commands to run โ what not to touch โ how PRs should be made โ what โdoneโ actually means Thatโs why files like AGENTS.md / CLAUDE.md matter more than people think.
@Layton_Gott ยท
9 things I've learned about AI coding that took me way too long to figure out: 1. AI will cheat on its own tests. It'll hardcode the answer or mock the exact function it's supposed to be testing so everything passes. Green checkmarks that prove nothing. Read the tests, not just the results. 2. More code is not more progress. AI loves to over build. Every extra line it writes is another place a bug can hide. The best AI sessions delete as much as they add. 3. It writes code that looks done and isn't. Less experienced devs can't tell the difference between code that works and code that lasts. That gap is the whole job now. 4. Tell it what NOT to touch. "Don't change anything I didn't ask for" saves you from it quietly renaming things and adding features you never wanted. 5. One chat, one task. The second you pile three things into one conversation the quality drops. Fresh thread per feature. 6. The stack matters more than people admit. AI is way better at popular, well documented tools because it trained on them. Pick a weird stack and you're on your own. 7. Three failed fixes means start over. If it can't fix the error in three tries, the chat is poisoned. Don't keep digging. Reset with a clearer prompt. 8. Prototyping is where it actually shines. Want to see what a big refactor looks like? Let it rip. The bar is low when you're throwing it away anyway. 9. It's an intern, not a senior. Great to start things, less useful the deeper and more complex it gets. Treat it like that and it stops disappointing you. The people getting burned by AI all treat it like it's smarter than it is. The ones shipping treat it like exactly what it is and build around the gaps.
@jsmasterypro ยท
"Agentic coding is a trap." Lars Faye's article making rounds today is worth your time: https://t.co/ue4YPknKF6 His core point: supervising AI requires the exact skills AI usage erodes. Anthropic's own research backs it. 47% drop in debugging skills. Juniors can't build foundations from reviewing code alone. Here's the weird thing. His prescribed antidote is basically the workflow we shipped in "How Senior Engineers Actually Build With AI": โ Specs first, written by you โ Planning mode before code โ Pseudo-code to close the gap between intent and output โ Never generate more than you can review in a sitting โ MCP servers (Context7, Figma, Playwright) so AI verifies its own work The trap isn't AI in your workflow. The trap is letting AI replace your thinking instead of augmenting it. Vibe coding atrophies you. Spec-driven orchestration doesn't.
@techNmak ยท
I miss one very specific feeling from coding. You spend an hour chasing a bug that makes absolutely no sense. You print variables everywhere, question your understanding of the language, change something that shouldn't possibly matter, restart your editor for no reason because at that point you're not debugging anymore you're just praying, and then it works. Sometimes you never even find out why. That little moment of satisfaction was one of the best parts of programming. AI coding agents are changing that experience in a way I didn't expect. Today I can describe the problem, let an agent inspect the repository, make the changes, run the tests, hit an error, fix its own mistake, and come back with a working result. Objectively that's incredible, but it doesn't always feel the same. Watching it happen isn't the same as doing it. At the same time, I'm not sure AI is taking the joy out of programming. Maybe it's just moving it somewhere else. The satisfying moment used to be "I finally solved it." Now it can be "I had an idea this morning and it exists this afternoon." Which makes me wonder if we actually loved writing code as much as we thought we did. Maybe what we loved was getting a computer to do something that had only existed in our head before. AI is removing a lot of the friction between those two things. Some of that friction absolutely deserved to die. I'm not convinced all of it did.
@ankrgyl ยท
there are 3 stages to ai coding: 1. i donโt trust the ai. let me write most of the code and ask it questions 2. wow i donโt need to write code anymore! let the ai write everything 3. oh wait, i just got a huge pile of slop. let me find the right balanceโฆ
@Suryanshti777 ยท
The hottest take in AI right now: the IDE is becoming the operating system for autonomous agents. Claude Code's new desktop launch isn't another coding assistant. It's an attempt to replace the entire developer workflow. One app now has: โข Parallel AI coding sessions with Git isolation โข Browser, terminal, editor and diff in one workspace โข Autonomous testing and self-verification โข Background cloud sessions that keep working after you close your laptop โข CI monitoring and auto-merge โข Phone-to-code dispatching โข Connectors, MCP servers and plugins The important shift isn't "Claude can code." It's that Claude is starting to: understand โ build โ test โ debug โ review โ ship with increasingly little human intervention. We're moving from: copilot โ coworker โ autonomous software engineer. I don't think the winners of this decade will be the models with the best autocomplete. They'll be the systems that can own the entire software development loop.
Watch video@johncrickett ยท
Tips for AI-Assisted software development: Avoid context clash to get cleaner code, faster iterations, and more reliable AI outputs. Context clash happens when you feed an AI coding agent conflicting context, unrelated code, mixed architectural patterns, or multiple objectives. When too many tasks, requirements, or codebases compete for attention, the model starts blending concepts that shouldn't be combined. AI performs best when context is relevant. The goal isn't to give the model more information, it's to give it just enough of the right information. A common example is asking an AI to write an authentication route while also providing unrelated database migrations, infrastructure code, or references to multiple frameworks. The result is often a Frankenstein solution that mixes patterns, introduces unnecessary complexity, and requires multiple rounds of corrections. Focused context produces better outcomes. When the model only sees the files, requirements, and constraints relevant to the task, it generates more accurate code, follows instructions more consistently, and reduces hallucinated carryover between tasks. The most common mistake is simply continuing a session after the original task has changed. Every additional task dilutes the quality of the context and potentially creates a clash. Do this in practice: - Use one chat per task. Keep tasks separate. - Start a fresh context window when switching to a new task. - Provide only the files, requirements, and goals relevant to the current task. - Use explicit file references or selections instead of sharing large sections of unrelated code. - Define architectural patterns and coding conventions upfront. - Restate critical constraints at the start of each session (better yet turn them into a file that can be ingested as part of the tasks context). One task. One session. Ship it. Then start fresh.
@_vmlops ยท
1.19M+ SKILLS HAVE BEEN INSTALLED FOR AI CODING AGENTS ON A SINGLE SITE AI agents now have an App Store https://t.co/dLbqnsXASY is an open directory where you install reusable "skills" for coding agents with a single command โ npx skills add <owner/repo> and you're done, no manual setup โ works across claude code, cursor, codex, copilot, windsurf, gemini, cline, and a dozen+ other agents โ leaderboard sorted by trending/hot/all-time โ top skills right now: a "find-skills" meta-skill, frontend design, TDD, code review, azure ops, prisma, supabase, and a wall of "taste" and design-system skills โ official packs from anthropic, microsoft, vercel, prisma, supabase, firebase already live basically npm, but for the procedural knowledge you hand your agent instead of the code it runs
Watch video
@asaio87 ยท
I think, along with AI Agents, we enter in a phase of software development that's called: "its good enough" Thats how ai coding agents work, and while its not the best coding out there, its good enough. We have two choices: 1/ go with the flow, as most apps dont get to have more than 10,000 users anyway, so any average coder can code that, let alone AI this is the path that 95% of people will follow and will fall into 2/ the apps that are made to scale, really need to be orchestrated more manual, than with AI and then ai can be used to write the boilerplace. The speed gain here is less than 10-20%
@smratitiwa86867 ยท
People are finally realizing something important: AI coding tools are not interchangeable anymore. One Reddit developer said Claude Code burned 40% of his usage, rewrote code twice, failed migrations, and still couldnโt find a basic env issue. Then Codex one-shotted the same task. Weโre entering the phase where โwhich modelโ matters less than: โ tool reliability โ repo understanding โ debugging accuracy โ autonomous decision making โ knowing when NOT to act The gap between AI demos and production-grade coding agents is becoming very visible very fast.
@xelebofficial ยท
Autonomous does not mean unsupervised. Around 60% of development work now involves AI assistance, yet developers fully delegate only 0 to 20% of tasks. This is not a lack of trust. It is professional judgment applied correctly. In practice, work falls into three zones: 1. Safe to delegate: boilerplate, tests, documentation, refactoring. AI executes, humans review. 2. Collaborative: complex features, debugging, code review. AI accelerates, humans stay involved. 3. Human owned: architecture, security, critical decisions. These remain non-negotiable. As agents become capable of writing code, deploying systems, and running for extended periods, the natural tendency is to push more work into the first category. Anthropicโs 2026 Agentic Coding Report identifies this as a key risk, including scope creep, hallucinated code reaching production, and agents operating beyond defined boundaries. The engineers navigating this shift most effectively are not those who delegate the most, but those who understand exactly where the boundary lies and enforce it. That judgment is becoming one of the most valuable skills in this transition. Source: Anthropic 2026 Agentic Coding Report
@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
@chappyasel ยท
I watched a video this week that gave me the perfect term for something Iโve been feeling in myself and seeing in a lot of other people building with AI: Cognitive debt. Such a good phrase!! Technical debt is the obvious stuff. Legacy patterns, messy abstractions, tests that are either missing or secretly useless. Cognitive debt is the scarier version because it lives in your own head. Itโs the gap between what your system does and what you can actually explain, debug, and safely change. This hit me because I am wildly bullish on AI coding. I use these tools constantly. They are incredible. It really does feel like having a team of tireless, slightly overconfident junior engineers next to you who will happily crank forever if you point them in a direction. And that is exactly why the phrase landed so hard. The code can start moving faster than your understanding. You ask for a feature. It creates plausible files. You ask for a refactor. It touches ten places. You ask for tests. They pass. Everything feels like progress until you hit a subtle product decision, a weird bug, or a teammate asks why something works the way it does. Then you realize the agent kept moving, and your mental model never caught up. Thatโs cognitive debt. The framework Iโve been using for myself is basically a speed governor for AI-assisted building: 1๏ธโฃ Determine the longevity of the project and how grokable it needs to be 2๏ธโฃ Determine your quality bar for the product 3๏ธโฃ Assess the current quality of coding agents 4๏ธโฃ Align with your team on how fast the product of โ allows you to move 5๏ธโฃ Continuously update โ Iโm more excited than ever about AI coding โ I just think the bottleneck is shifting! The question is no longer only โhow much code can we produce?โ โ itโs โhow much of what we produce can we still understand?โ
@thetechstartups ยท
AI coding is all the rage right now. And honestly? The hype is both realโฆ and misunderstood. I think AI coding follows roughly 5 stages: Amazement You try it and your brain melts. A few prompts generate: โข apps โข APIs โข landing pages โข features โข entire prototypes Productivity suddenly feels 10x. Expansion You start more and more projects because shipping now feels cheap and fast. This is also where the social contagion kicks in. People start convincing: โข coworkers โข managers โข founders โข entire companies because nobody wants to be the one left behind. FOMO becomes a growth engine. The Grind Phase Reality starts showing up. The generated code worksโฆ until: โข edge cases appear โข scale increases โข architecture matters โข multiple developers touch the codebase Then come: โข duplicated logic โข brittle abstractions โข hidden bugs โข security holes โข endless re-prompting You slowly realize youโre spending more time reviewing AI-generated code than writing software yourself. Realization This is the big insight: AI increases output much faster than it increases certainty. The code still needs: โข testing โข ownership โข architectural judgment โข maintenance โข operational discipline Usually from experienced engineers. Integration / Maturity Then something interesting happens. Teams stop treating AI like magic and start treating it like infrastructure. Workflows improve. Guardrails emerge. Engineers become AI-augmented. Small teams suddenly operate like much larger ones. And software creation itself starts becoming conversational. Thatโs why I think AI coding was probably overhyped in the short termโฆ โฆbut still underestimated in the long term. Full story on TechStartups ๐ #AICoding #SoftwareEngineering #VibeCoding #AI #Startups #AICodingHype #HypeCycle
@CoreyGallon ยท
Coding agents can now finish tasks that would take a human 16 to 18 hours. @tariqshaukat opens "In the Land of AI Agents, the Verifiers Are King" by pointing at the footnote nobody reads: that benchmark is measured at a 50% success rate. Dial accuracy up to 80% and the number falls to about three and a half hours. The talk is on @aiDotEngineer's YouTube. Tariq is CEO of Sonar, and was previously President of Google Cloud and President of Bumble. It's a working argument for treating verification as part of how code gets generated, not as the review step you bolt on afterward. - The productivity boost has a half-life. A Carnegie Mellon study found a three to five times velocity jump from AI coding agents that dissipates in about three months, as security, maintainability, reliability, and complexity issues pile up. - Functional correctness is the easy part. Sonar's benchmark runs over 4,000 problems through the models. They all do extremely well on functional correctness, then still ship complexity, bugs, and security issues. - Guide is preemptive verification. Give agents context (architectural awareness, semantic navigation of the repo) and constraints (coding standards, allowed dependencies, intended architecture) as two separate things. Tariq reports over 30% fewer tokens to solve a given problem. - Zero trust, multi-layered. Every model has its own biases and character, so verify with different models and different techniques. Algorithmic checks catch data flows, control flows, known patterns, and secrets; agentic checks go after intent, business logic, and unknown unknowns. - The reliability number. Customers running multi-layered verification report AI-derived production outages 44% less frequent than those who don't. - Three loops, not one gate. The agentic loop (in-loop verification while the agent works), the CI verification loop (agent-assisted review plus evals and quality gates), and the code maintenance loop. Sonar calls the whole thing the agent-centric development cycle. - Clean code is an agent concern. Run the same agentic task against a typical code base and a cleaned one, and the cleaned one needs materially fewer tokens and less reasoning, because the agent has to understand the code before it can operate on it. - It compounds either way. One large bank using cutting-edge agentic coding tools saw a 92% reduction in issues with guide, verify, solve built into the loops. Neglect verification and the same system spirals in the other direction. I'm working through the published talks from AI Engineer World's Fair sharing summaries and takeaways. Follow for more!
Watch video@DivyanshT91162 ยท
Holy shit.....this is the first AI coding agent I didnโt blindly trustโฆ and thatโs exactly why it worked. I donโt trust most AI with production code. Especially not when an endpoint is handling 50K+ active sessions. One bad commit = users logged outโฆ or worse, tokens exposed. Last week I had to refactor our auth system: Add OAuth2 alongside existing JWT โ without breaking anything live. So I tested Junie from JetBrains. Hereโs what surprised me: Instead of jumping into code, it mapped the system first. It opened 15+ files โ session manager, middleware, error handlers โ and explained how everything was connected. Then it suggested separating auth into its own service layer. I asked why. โBetter isolation. Easier testing. Future provider swaps become trivial.โ Fair. Next โ it wanted refresh tokens in DB. I pushed back. Said I want in-memory for speed. It didnโt argue. It adapted instantly. No reset. No friction. The code? Not perfect. I rewrote parts of the error handling. But for the first time โ I actually understood every decision. And that changed everything. Because reviewing AI code > trusting AI code. The wildest part? I triggered a refactor directly from a GitHub PR comment. No IDE. No setup. It ran async while I reviewed other code. Thatโs when it clicked: This isnโt โvibe codingโ. This is collaboration. If this is where AI agents are goingโฆ developers who can review deeply will win.
Watch video
@ThePracticalDev ยท
AI coding agents still struggle with repo context, not syntax. Things like which test command to run, what naming conventions are used, or what tooling is configured. This dev built Agentskill to compile repository reality into agent-usable instructions. { author: @airscript } https://t.co/h2DXLIuaae
@michaelyinplus ยท
AI is helping a lot of non programmers ship great products. But if you donโt understand the underlying techs, youโre just building a time bomb. AI can generate code fast, however, maintaining and refactoring it still requires real engineering experience. https://t.co/tFSojofmca #AI #Coding #LLM #SoftwareEngineering
@JustAnotherPM ยท
Most people think AI coding agents make engineering easier. Unfortunately, that is not true. The real unlock is that they make junior engineering nearly impossible, and senior engineering exhausting. Without a decade of pattern matching, you cannot tell when an agent is hallucinating an architecture, eating its own context, or about to corrupt a migration. If you have no senior judgement, an agent is just a faster way to ship the wrong thing. If you have senior judgement, an agent is a 4x multiplier. But it taxes that judgement on every single decision you make. Two things this changes for AI PMs in 2026: ๐ญ. The most valuable hire on your team is the engineer who has built and broken systems for ten years. They are the only one who can keep agents in line. ๐ฎ. The most valuable habit you can build is reading agent transcripts every day. Not the output. The reasoning. That is where the failure modes hide. The teams that figure this out are shipping in days. The teams that hand agents to juniors and walk away are spending the same six months as before. They just have prettier diffs.
@alex_verem ยท
Found an open-source project that fixes the biggest flaw in AI coding tools. The AI grades its own homework. When one AI model plans a feature, builds it, and then checks its own work, it tends to wave through its own mistakes. It already decided the approach was right, so of course the review passes. The same blind spots that caused the bug are the ones judging whether there's a bug. Sol Advisor is a workflow built to break that loop. It splits the job across separate roles instead of one model doing everything. An architect role plans the work and writes the spec. Two builder roles handle the actual coding, a lighter one for routine work and a heavier one for the risky, complicated stuff. Before anything ships, a fresh reviewer looks at the finished code with no memory of the conversation that produced it. It doesn't know what the builder was thinking or what got assumed along the way. It just sees the diff and the evidence, and it returns one of three verdicts. Ship it, fix it first, or rethink the whole thing. The work isn't allowed to be marked done until that clean review says ship. The fresh eyes are the whole idea. Most AI coding setups let the same context that wrote the code also approve it, which is how confident mistakes slip through. Sol Advisor forces the final look to happen cold, the way a second engineer catches what the author has gone blind to. It's early and it's built for one specific toolchain, so most people can't just drop it in yet. But the core idea travels. If you're going to trust AI with real work, don't let it be the one who signs off that the work is good.
@H0wie_Xu ยท
๐จ #AI is not coming. Itโs already hereโand moving faster than most realize. I had a fascinating conversation with @MatanGrinberg, founder & CEO of @FactoryAI who raised $30M from @sequoia . The discussion on AI Coding Agents primarilyโjoined by @furrier โunpacked some deep truths about software engineering, education, and what it means to build in an #AIFirst world. ๐ก What makes a great software engineer today? Itโs no longer about knowing every programming language. Matan put it simply: โThe best developers are systems thinkers.โ Hereโs what that looks like in practice: โ Design scalable, intelligent systems โ Break work into modular chunks that AI can execute in parallel ๐ In other words: think like a senior tech lead, not a code monkey. ๐ Agile is the new legacy John quipped, โAgile is modern legacy.โ Heโs not wrong. From my own experience, Agile breaks down quickly in #AIFirst development. Weโre entering a new era that demands new operating models. ๐ง What should kids be learning today? Before founding https://t.co/uCpND6AEs9, Matan studied theoretical physicsโwhich taught him: Systems thinking; Complex reasoning; Navigating constraints. These skills are still uniquely humanโand will be more valuable than ever in the AI era. โ AI Coding Coverage = The New Standard At https://t.co/uCpND6AEs9, 100% of the code is already done by AI, with human supervision. This isnโt theoretical. Itโs realโand fast becoming the norm. Large enterprises are catching up. The behavior change is always hard but as usual, the industry peers and competitors will not give you a lot of time for the transformation. The adoption bottleneck isn't at the technology but at the human level. Matan joked: I missed mobile. I missed cloud. But Iโm going all in on AI. That mindset is actually widespread among Fortune 500 CEOs too ๐ค SF: 7x7 Miles of San Francisco Matan and John shared a bold vision: In 10โ12 years, San Francisco may have more humanoid robots than humans. Today, there are already more @Waymo self-driving cars than @lyftsolutions on the road. ๐ The AI-native world isnโt tomorrow. Itโs already here. Are you ready? Thanks to Byte Into Future SiliconANGLE & theCUBE NYSE Wired, here is the video interview link: https://t.co/jfIIt4l7L7
@H0wie_Xu ยท
๐ Last Saturday I had the honor of giving an opening #keynote at the #Vibe #Coding Summit held at #AGI #Houseโa house where visionaries like @OpenAI cofounder @karpathy lived and @Google 's @JeffDean , and cofounder Sergey Brin have all left their mark. My own learning after spending a day at AGI House: Golden Age for #Builders, Tough for #Coders. AI Coding presents both an existential threat and an unprecedented opportunity for the entire #SiliconValley. I sat down with two brilliant CTO-cofounders, Jonathan Shobrook and Jay Ma of @finalround_ai, to dive into the evolving world of coding agents. Please watch the interview in entirety here: https://t.co/UDUsbGLBeD While many developers only see a modest ~10% productivity boost, Jonathan and Jay's team got a lot more. They reframed the question: Maybe the problem isnโt the toolsโitโs how we use them. Your mileage may vary, but here are some hard-earned insights on unlocking greater productivity. ๐ Key Takeaways: ๐งช Vibe coding is useful beyond prototyping The real bottleneck isnโt prototypingโitโs testing. Set up your verifier before you start building. ๐ง Teach the agent, teach the AI Success hinges on context, including all the tribe knowledges and internal wikis. โฑ๏ธ From linear to parallel workflows โTransform from a linear work schedule into parallel agent work schedule.โ What once took weeks can now take days. ๐งญ Programming skill is secondaryโengineering management is key AI is the intern. Your job is managing them. Senior engineers are more valuable than ever. ๐ The โstandard career pathโ is dead Junior devs should learn to direct AI from day one. ๐ New engineers adapt faster Vibe coding can feel intimidating to seasoned devsโbut for new builders, itโs the default. โ ๏ธ Golden age for builders, tough for coders Traditional professionals may struggle to adapt. But for those who do? Thereโs never been a better time to build. /thread
Best AI Coding tweets
Xholic studies what works in your niche, drafts posts in your voice and schedules them for the hours your audience is online.
No card needed ยท Nothing to cancel
Browse all tweet collectionsLive demo: no sign-up or login needed ยท takes about 2 minutes
Keep exploring