How to Boost Productivity With Developer Agents

Most developers use AI to write code faster. The best ones use it to stop writing code entirely. Today, I spend 80% of my time describing what I want, reviewing what agents build, and deciding when to step in. The other 20% is architecture and security calls that agents can't make yet. This isn't lazy. It's the new job. Anthropic's 2026 Agentic Coding Trends Report confirmed what I've been feeling: developers now integrate AI into 60% of their work while maintaining active oversight on 80-100% of delegated tasks. The role shifted from "person who writes code" to "person who directs and reviews code." Here are 5 skills I had to learn the hard way: 𝟭. 𝗪𝗿𝗶𝘁𝗶𝗻𝗴 𝗦𝗽𝗲𝗰𝘀, 𝗡𝗼𝘁 𝗖𝗼𝗱𝗲 The quality of what an agent builds is directly proportional to how well you describe what you want. Vague prompt = vague code. I now spend more time writing specs than I ever spent writing implementations. 𝟮. 𝗧𝗮𝘀𝗸 𝗗𝗲𝗰𝗼𝗺𝗽𝗼𝘀𝗶𝘁𝗶𝗼𝗻 Agents lose context on large tasks and waste time on tiny ones. The skill is finding the sweet spot: chunks big enough to be meaningful, small enough to stay accurate. 𝟯. 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 Agents forget everything between sessions. Your project rules, memory files, and AGENTS .md are what give them continuity. This is the most underrated skill on the list. 𝟰. 𝗥𝗲𝘃𝗶𝗲𝘄𝗶𝗻𝗴 𝗔𝗜 𝗢𝘂𝘁𝗽𝘂𝘁 Agents generate code fast. They also generate security holes, edge case gaps, and subtle architectural drift fast. Your job is catching what they miss. This is harder than writing the code yourself. 𝟱. 𝗞𝗻𝗼𝘄𝗶𝗻𝗴 𝗪𝗵𝗲𝗻 𝘁𝗼 𝗦𝘁𝗲𝗽 𝗜𝗻 Architecture decisions and security calls are still yours. Everything else? Let the agent iterate. The hardest part isn't learning to delegate. It's learning to stop grabbing the keyboard back. The developers who thrive in 2026 won't be the fastest coders. They'll be the best agent operators. Which of these 5 are you already doing?

Agent-assisted coding transformed my workflow. Most folks aren’t getting the full value from coding agents—mainly because there’s not much knowledge sharing yet. Curious how to unlock more productivity with AI agents? Here’s what’s worked for me. After months of experimenting with coding agents, I’ve noticed that while many people use them, there’s little shared guidance on how to get the most out of them. I’ve picked up a few patterns that consistently boost my productivity and code quality. Iterating 2-3 times on a detailed plan with my AI assistant before writing any code has saved me countless hours of rework. Start with a detailed plan—work with your AI to outline implementation, testing, and documentation before coding. Iterate on this plan until it’s crystal clear. Ask your agent to write docs and tests first. This sets clear requirements and leads to better code. Create an "AGENTS.md" file in your repo. It’s the AI’s university—store all project-specific instructions there for consistent results. Control the agent’s pace. Ask it to walk you through changes step by step, so you’re never overwhelmed by a massive diff. Let agents use CLI tools directly, and encourage them to write temporary scripts to validate their own code. This saves time and reduces context switching. Build your own productivity tools—custom scripts, aliases, and hooks compound efficiency over time. If you’re exploring agent-assisted programming, I’d love to hear your experiences! Check out my full write-up for more actionable tips: https://lnkd.in/eSZStXUe What’s one pattern or tool that’s made your AI-assisted coding more productive? #ai #programming #productivity #softwaredevelopment #automation

BREAKING: Anthropic launches Claude Opus 4.5 Several of the upgrades are squarely at people like me, developers building agents. I'm particularly impressed with how elegantly they handle one of the biggest issues developers are dealing with: tool calling. MCP is great (as a protocol) but has a major issue with how it front-loads the context window and consuming a lot of tokens. It's easy to have a run-away set of MCP servers/tools that clutter the context window and degrade performance. So, here's what we have now (that I'm playing with for the next 12 hours): 1. Tool Search Instead of shoving every tool definition into the model up front (like packing your entire house for a weekend trip), Claude can now fetch tool definitions only when it needs them. Fewer tokens. Faster responses. Less clutter. More joy. 2. Programmatic Tool Calling Claude can now write code to orchestrate multiple tools without dragging every intermediate result back into the model’s context. Think of it as moving from “chatty assistant” to “competent developer who actually reads the docs.” 3. Tool Use Examples You can now give example calls to show how a tool should be used—not just what fields it has. This dramatically reduces the “I see your schema and choose chaos anyway” problem. Why this matters: If you’re building agent workflows with lots of tools, these upgrades cut token usage, reduce latency, improve reliability, and generally make your agent behave more like a well-trained teammate and less like an overeager intern. My take: As agent architectures get more complex, the bottleneck isn’t the model—it's the orchestration. These features move us closer to agents that can reason, retrieve, call tools, and coordinate real work at scale. In other words: better plumbing, better agents. If you're building anything agent-heavy, it’s worth a look. p.s. The image was created with my new ImageGen .ai agent (single prompt consisting of the text of the post).

If your job is providing you unlimited AI access for coding, you are doing yourself a disservice by NOT going full send with agents. To be very clear, I'm not advocating for throwing AI slop into production or forcing your colleagues to review code you didn't think through. What I am saying is that you should create a low stakes scratch repo and take it to its limits. Similar to how you evaluate a new tool by pressure testing and intentionally breaking it, you need to do this with the current agents. I recently went through this exercise and this is what I learned: 1. Tools are opinionated, so learn how to structure your repo accordingly. For Claude Code you need a CLAUDE.md file and .claude/ directory to fully take advantage of the tool. 2. Similar to how you setup your dev environment for a program language, you need to do the same for your agent. You can do this by having a thoughtful CLAUDE.md file and copying key dev docs from tools you are using into .claude/docs/ as a markdown file (this is where people are using "skills"). 3. The highest leverage configuration is getting your agent to be exceptional with git and the GitHub CLI command as this allows it to quickly pull context about your project state. A CLAUDE.md file with proper software engineering principles documented (eg commit often, and pull requests can't be larger than 500 lines, each commit is a single piece of logic implemented, etc) 4. Protect your "main" branch is standard advice regardless, but it's critical when working with agents as you need to be the final review for all code entering the main branch. With that said, I let my agent create, manage, and edit everything else on GitHub. 5. Pre-commit and post-commit hook automations that self document context and updates is crucial (hence why small commits are important). But also create JSON files that document the actions taken by the agent for a specific commit, so it can use that context quickly for development decisions. 6. Writing my own context docs and prompts is a bottleneck. I instead focus on curating context and documentation, organizing created information, and constantly deleting irrelevant or merging duplicate information. The LLM can create way better prompts than me, and "planning" mode suffices. 7. Spec driven development (SDD) via GitHub's Spec-Kit framework created a major inflection point where I went from actively guiding my agent to letting it run fully on its own completing task after task with minimal input beyond "yes you can use that command in this folder"... Most of my "development" time was here refining the spec, guardrails, tests, etc. 8. Once you get to this point, a single terminal session no longer suffices. You have to start running agents in parallel to get the 10x gains, and tools are still catching up. Right now I use iTerm2 with tmux (multiple terminal tabs in a window) and give claude access to the it2 CLI to start and end terminals. ... continued below (hit char limit)

Spent way too much time building agents that never worked? Been there! After reading this LangChain guide and reflecting on my own messy journey, here’s the 6-step framework that actually works:- 1. Define with examples (not dreams) Stop saying “it’ll handle everything!” Start with 5-10 concrete examples. If you can’t teach it to a smart intern, your scope is probably broken. 2. Write the manual first Before touching any code, write out step-by-step instructions for how a human would do this task. Boring? Yes. Essential? Absolutely. 3. Build MVP with just prompts Focus on ONE core reasoning task. Get that prompt working with hand-fed data before you get fancy. Most agents fail here because we skip the fundamentals. 4. Connect the pipes Now connect real data sources. Gmail API, calendar, whatever. Start simple - resist the urge to build something that calls 47 different APIs. 5. Test like your job depends on it Run your original examples through the system. Set up automated testing. Use tools like LangSmith to see what’s actually happening under the hood. 6. Deploy and learn Ship it, watch how people actually use it (spoiler: differently than you expected), then iterate. Launch is the beginning, not the end. Real talk:- I’ve broken every one of these rules and paid for it. The “smart intern” test alone would’ve saved me months of chasing impossible dreams. What’s been your biggest agent-building experience? #AI #Agents #LLM #ProductDevelopment

Ever wished you could keep coding with AI assistance during your commute? I ride BART every day, and those 30-40 minute underground stretches used to be dead time. Not anymore. Using Continue's agent mode with Ollama, I've turned my daily commute into focused coding sessions—completely offline. The key? Context engineering. Before losing signal, I prepare PRDs (Product Requirement Documents) that outline exactly what I want to build. I've set up rules that teach the AI our team's conventions. And I've indexed my entire codebase locally. When the train goes underground, I have everything needed for productive work. No Stack Overflow rabbit holes, no Twitter distractions—just focused implementation with AI assistance. Research shows 69% of developers lose over 8 hours per week to inefficiencies, and it takes 52 minutes of uninterrupted time to reach flow state. My BART rides give me that uninterrupted time twice daily. Over a week, those 30-minute sessions compound into real features shipped and technical debt addressed. The best part? Complete privacy. Your code never leaves your machine. No telemetry, no data retention policies. Whether you're in a secure environment, on a flight, or just trying to focus, your AI coding assistant works anywhere. Sometimes the best code really does get written underground. #DeveloperProductivity #AIAssistedCoding #LocalFirstDevelopment

Your engineers only spend 30% of their time writing code. AI tools are getting faster every month. But if we only use them to optimize that 30%, we’re missing the bigger opportunity. The real drag on engineering teams isn’t just how long it takes to code. It’s everything else. Here’s what fills the other 70%: •Chasing down unclear requirements •Sitting in meetings with no clear outcomes •Reviewing pull requests with inconsistent standards •Updating tickets and writing status reports •Answering Slack threads that go nowhere •Debugging issues without structured history •Repeating the same explanation of tech debt, again and again •Waiting on test runs and deployment gates •Switching contexts so often they lose flow entirely I’ve seen teams implement AI coding assistants and celebrate a 50%+ speedup—in just the 30% coding time. But if you do the math, that’s only a 15% productivity gain overall. Helpful? Sure. Transformative? Not yet. The teams moving faster right now are thinking differently. They’re using AI tools to remove the clutter around the code, not just speed up the code itself. •Auto-summarizing Slack threads and meeting notes •Auto-generating technical documentation and PR templates •Using AI to enrich ticket context before a dev even picks it up •Automating deployment comms with intelligent summaries •Creating internal agents that proactively surface blockers If you want a truly AI-first team, you can’t just deploy tools for the 30%. You need to reimagine the 70%. That’s where the friction lives, and where the real leverage is hiding. Have you mapped where your team spends their time? If not, that’s where your AI roadmap should start. #EngineeringLeadership #AIProductivity #DeveloperExperience #TechStrategy #MetaShift #SoftwareDevelopment #AIatWork

𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝘄𝗶𝘁𝗵 𝗔𝗜 𝗖𝗼𝗱𝗶𝗻𝗴 𝗧𝗼𝗱𝗮𝘆: You prompt → AI writes code → You ship → You start from zero. Every. Single. Time. This is why most developers plateau. They treat AI like chat bots. Top performers do something different: 𝗖𝗼𝗺𝗽𝗼𝘂𝗻𝗱 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴. ━━━━━━━━━━━━━━━━━━━━ 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗶𝘁? Building AI systems with memory. → Every PR educates the system → Every bug becomes a permanent lesson → Every code review updates agent behavior Regular AI coding makes you productive 𝘁𝗼𝗱𝗮𝘆. Compound Engineering makes you better 𝗲𝘃𝗲𝗿𝘆 𝗱𝗮𝘆 𝗮𝗳𝘁𝗲𝗿. ━━━━━━━━━━━━━━━━━━━━ 𝟰 𝗔𝗰𝘁𝗶𝗼𝗻𝘀 𝘁𝗼 𝗜𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁: 𝟭. 𝗖𝗼𝗱𝗶𝗳𝘆 𝗬𝗼𝘂𝗿 𝗘𝘅𝗽𝗲𝗿𝗶𝗲𝗻𝗰𝗲 Create AGENTS.md or .cursorrules in your repo. Document patterns, pitfalls, and PR references. This becomes your AI's "onboarding doc." 𝟮. 𝗠𝗮𝗸𝗲 𝗕𝘂𝗴𝘀 𝗣𝗮𝘆 𝗗𝗶𝘃𝗶𝗱𝗲𝗻𝗱𝘀 When fixing bugs, ask: Can a lint rule prevent this? Should AGENTS.md document it? A true fix ensures the agent never repeats it. 𝟯. 𝗘𝘅𝘁𝗿𝗮𝗰𝘁 𝗥𝗲𝘃𝗶𝗲𝘄 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 Every review comment is a potential system upgrade. Turn feedback into reusable standards the agent auto-applies. 𝟰. 𝗕𝘂𝗶𝗹𝗱 𝗥𝗲𝘂𝘀𝗮𝗯𝗹𝗲 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀 Document task sequences. Next time: "Follow the add API endpoint workflow." The system already knows what to do. ━━━━━━━━━━━━━━━━━━━━ 𝗧𝗵𝗲 𝗖𝗼𝗺𝗽𝗼𝘂𝗻𝗱 𝗘𝗳𝗳𝗲𝗰𝘁 Imagine the AI saying: "Naming updated per PR #234. Over-testing removed per PR #219 feedback." It learned your taste—like a smart colleague with receipts. ━━━━━━━━━━━━━━━━━━━━ 𝗧𝗵𝗲 𝗟𝗲𝘃𝗲𝗿𝗮𝗴𝗲 𝗛𝗶𝗲𝗿𝗮𝗿𝗰𝗵𝘆 Bad code = one line affected Bad AGENTS.md instruction = 𝗲𝘃𝗲𝗿𝘆 𝘀𝗲𝘀𝘀𝗶𝗼𝗻 affected Treat agent config like production code. Highest-ROI investment you can make. ━━━━━━━━━━━━━━━━━━━━ Stop treating AI interactions as disposable. Start treating them as investments. That's how you go from "AI User" to "𝗔𝗜 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗶𝗲𝗿." What's one pattern you've compounded into your AI workflow? 👇 #AgenticCoding #SoftwareEngineering #TechLeadership #GenAI #DeveloperProductivity

𝗛𝗼𝘄 𝘁𝗼 𝗔𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗠𝗮𝗸𝗲 𝗔𝗜 𝗖𝗼𝗱𝗶𝗻𝗴 𝗔𝗴𝗲𝗻𝘁𝘀 𝗗𝗲𝗹𝗶𝘃𝗲𝗿 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆 𝗳𝗼𝗿 𝗕𝗿𝗼𝘄𝗻𝗳𝗶𝗲𝗹𝗱 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 Every vendor demo shows pristine greenfield examples. Every enterprise deals with brownfield codebases developed over years. 𝗜'𝘃𝗲 𝗹𝗶𝘃𝗲𝗱 𝘁𝗵𝗶𝘀 𝗱𝗶𝘀𝗰𝗼𝗻𝗻𝗲𝗰𝘁 𝗳𝗶𝗿𝘀𝘁𝗵𝗮𝗻𝗱: A 2025 METR study tracked experienced developers using AI coding agents on enterprise systems. The result? 𝟭𝟵% 𝘀𝗹𝗼𝘄𝗲𝗿 𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗶𝗼𝗻 𝘁𝗶𝗺𝗲𝘀. Meanwhile, the same developers see 30-55% productivity gains on new projects. 𝗛𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘄𝗼𝗿𝗸𝘀: Stop treating AI agents like fancy autocomplete. Start treating them like new hires who need proper onboarding. 𝗪𝗵𝗮𝘁 𝘄𝗲 𝗹𝗲𝗮𝗿𝗻𝗲𝗱 𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝘄𝗮𝘆: Automate Context Engineering to make AI Coding Agents Effective for Brownfield projects. Before your AI writes a single line of code, it needs to understand: • Your business logic (the stuff that's only in Sarah's head from 2018) • Architectural constraints (why that function can't be touched) • Dependencies (what breaks when you change this module) 𝗧𝗵𝗿𝗲𝗲-𝗽𝗵𝗮𝘀𝗲 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝘁𝗵𝗮𝘁'𝘀 𝘄𝗼𝗿𝗸𝗶𝗻𝗴: 𝗣𝗵𝗮𝘀𝗲 𝟭: 𝗔𝗜 𝗮𝘀 "𝗰𝗼𝗱𝗲 𝗮𝗿𝗰𝗵𝗮𝗲𝗼𝗹𝗼𝗴𝗶𝘀𝘁" Map dependencies, identify hotspots, generate missing documentation 𝗣𝗵𝗮𝘀𝗲 𝟮: 𝗕𝘂𝗶𝗹𝗱 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀 Continuous documentation, automated requirements extraction, living knowledge base 𝗣𝗵𝗮𝘀𝗲 𝟯: 𝗖𝗜/𝗖𝗗 𝗴𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲 Trust but verify everything, automated validation, self-correcting loops 𝗥𝗲𝗮𝗹 𝗿𝗲𝘀𝘂𝗹𝘁: One team went from 19% slower to 25% faster in 90 days. 𝗧𝗵𝗲 𝗵𝗮𝗿𝗱 𝘁𝗿𝘂𝘁𝗵: This isn't about deploying more agents. It's about making your legacy systems AI-ready. 𝗥𝗲𝗮𝗹𝗶𝘁𝘆 𝗰𝗵𝗲𝗰𝗸 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻: AI is generating tons of code for your teams. But how many of you are actually measuring what percentage makes it into your final deployed codebase? #EnterpriseAI #TechLeadership #AIStrategy #AICoding

How can we vibe code while still maintaining code quality? Over the past year, I've shifted 95% of my development from manually writing code to using coding agents. I wrote this blog on some tricks I learned to work successfully with agents: https://lnkd.in/gZzPGzhU Some background is that we're working on the coding agent OpenHands: https://app.all-hands.dev/ It's a pretty complex project with a Python backend, TypeScript frontend, extensive use of docker, etc. etc. So maintaining code quality is paramount. Trick 1: lean heavily on static analysis tools. If writing in a weakly typed language like Python, use type annotations and checking w/ mypy or pyright. Lint with a tool like ruff, and make sure that you use pre-commit so the agent doesn't "forget". Trick 2: practice test-driven development. Agents often get lazy and commit code that doesn't really fix your problem. But if you ask them to write tests first before writing any code to fix things, this results in much better results. Trick 3: use continuous integration. This allows you to make sure that tests are run on every pull request. Agents can be asked to monitor github actions and fix any resulting bugs. Trick 4: customize instructions for repositories. Each repository may have slightly different rules, so you can customize prompts and setup scripts for your repo. Trick 5: perform two-tiered code review. In big software projects code review is standard, but when working with agents, we first have the person who invokes the agent review the agent's code as a draft PR, then a second review review the full PR. This is just an initial list, so if you have any feedback on the tricks I wrote here, or other suggested ones I'd love to hear them. And there's many more details in the blog at the top of the thread!