Enhancing Developer Experience

“Loop engineering” is a hot buzzphrase after mentions of it by Boris Cherny (Claude Code’s creator) and Peter Steinberger (OpenClaw's creator) went viral on social media. Loops are now a key part of how we get AI agents to iterate at length to build software. In this letter, I’d like to share my 3 key loops, shown in the image below, for building 0-to-1 products. These loops guide not just how I build software, but also how I decide what software to build. Agentic coding loop: Given a product specification and optionally a set of evals (that is, a dataset against which to measure performance), we can have an AI agent write code, test its work, and keep iterating until the code is bug-free and meets its specification. This idea of closing the loop took off around the end of last year, and it has been a game changer in enabling coding agents to work longer productively without human intervention. For example, over the weekend, I was building an app for my daughter to practice typing, and my coding agent could easily work for around an hour, using a web browser to check what it had built multiple times before getting back to me, without needing my intervention. The engineering loop executes quickly. Every few minutes, the coding agent might build and test a new version of the software. I hear frequently from developers who are finding new ways to engineer more effective engineering loops. This is an active area of invention! Developer feedback loop: In this loop, a developer examines the current product and steers the coding agent to improve it. Last year, a lot of developers (including me) were acting as the QA (quality assurance) function for our coding agents, manually finding bugs and then asking the agent to fix them. But with coding agents much more able to test their own code, the amount of time we need to spend on this function has decreased significantly. This allows us to make higher-level product decisions, such as what key features to offer, where the UI needs improvement, and so on. The developer-feedback loop operates over time intervals between tens of minutes and hours — that's how frequently a developer might review a product and give feedback. In the case of the typing app, I changed my mind a few times about the visual design, what cat costumes she can unlock as she learns (she loves cats), and the user flow for a grown-up to log in and steer the child's learning experience. When a developer has a clear vision for what to build, it is still a lot of work to translate that vision into a specification for a coding agent to implement. Further, after the developer has seen an implementation, they might update (or perhaps clarify) the spec to steer it toward what they want. If you find that the system repeatedly runs into certain problems, building a set of evals for the agent becomes useful. [Truncated for length. Full text: https://lnkd.in/gKDQ6H9s]

"Feedback is a gift. It's an opportunity to learn and grow" At Google, we believe in the power of feedback to drive improvement. Sometimes feedback can be tough to hear. But taking the time to unpack it, understand the perspective, and reflect on it is crucial. Why feedback matters: - It reveals blind spots we cannot see ourselves - It accelerates learning by shortcutting trial and error - It demonstrates that others are invested in your success - It creates alignment between perception and reality How to receive feedback effectively: 1. Approach with curiosity, not defensiveness When receiving feedback, your first reaction might be to justify or explain. Instead, listen deeply and ask clarifying questions: "Can you give me a specific example?" or "What would success look like to you?" 2. Separate intention from impact Remember that well-intentioned actions can still have unintended consequences. Focus on understanding the impact rather than defending your intentions. 3. Look for patterns across multiple sources Individual feedback may reflect personal preferences, but patterns across multiple sources often reveal genuine opportunities for growth. 4. Prioritize actionable insights Not all feedback requires action. Evaluate which points will have the greatest impact on your effectiveness and focus your energy there. 5. Follow up and close the loop Demonstrate your commitment by acknowledging the feedback, sharing your action plan, and following up on your progress. Creating a feedback-rich environment: - Model vulnerability by asking for feedback yourself - Recognize and celebrate when people implement feedback successfully - Make it routine through structured check-ins rather than waiting for formal reviews At Google, we've learned that organizations with robust feedback cultures innovate faster, adapt more quickly to market changes, and build more inclusive workplaces. Let's commit to seeing feedback not as criticism but as a valuable investment in our collective future. The discomfort is temporary, but the growth is lasting. #motivation #productivity #mindset

One of the easiest ways to improve your collaboration with product managers and engineers is to improve your design handoff files. - It doesn’t take a lot of time - It drastically improves how people interpret your designs - It reduces backs and forths between engineers and designers - It gives engineers confidence that they are doing the right thing - It increases the chances that what’s implemented will match the design Great handoff files, for me, are an instant sign of design maturity. It shows me that designers think not only of themselves but also the ecosystem of people around them. Coming up with great handoffs boils down to the following: - Setting context - Adding structure - Adding annotations - Including all states - Visualizing the flow - Including a prototype - Doing a run-through Not everything is required for every design initiative; a small feature update may not need a full handoff, whereas a big, impactful one may require everything from the above. In this cheat sheet, I’ve put together my top tips for delivering the “perfect” handoff file. Bonus: I have also created a Figma Annotation and handoff kit with handy components for the above. Find the link in the comments. 👇 — If you found this useful, consider reposting ♻️ PS: By handoff I'm not referring to the process of handing over a design, which should be a collaborative process from problem to solution, but rather the organized design file that is the single source of truth for what needs to be implemented. #uxdesign #uiux #productdesign

Anthropic 𝗷𝘂𝘀𝘁 𝗿𝗲𝗹𝗲𝗮𝘀𝗲𝗱 𝗮 𝗱𝗲𝗻𝘀𝗲 𝗮𝗻𝗱 𝗵𝗶𝗴𝗵𝗹𝘆 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗿𝗲𝗽𝗼𝗿𝘁 𝗼𝗻 𝗵𝗼𝘄 𝘁𝗼 𝗯𝘂𝗶𝗹𝗱 𝗲𝗳𝗳𝗲𝗰𝘁𝗶𝘃𝗲 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝗽𝗮𝗰𝗸𝗲𝗱 𝘄𝗶𝘁𝗵 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗿𝗼𝗺 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗱𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁𝘀: ⬇️ Not just marketing, BUT a real, practical blueprint for developers and teams building AI agents that actually work. It explains how Claude Code (tool for agentic coding) can function as a software developer: writing, reviewing, testing, and even managing Git workflows autonomously. BUT in my view: The principles and patterns described in this document are not Claude-specific. You can apply them to any coding agent — from OpenAI’s Codex to Goose, Aider, or even tools like Cursor and GitHub Copilot Workspace. 𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 7 𝗸𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁𝘀 𝗳𝗼𝗿 𝗯𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗯𝗲𝘁𝘁𝗲𝗿 𝗔𝗜 𝗮𝗴𝗲𝗻𝘁𝘀 — 𝘁𝗵𝗮𝘁 𝘄𝗼𝗿𝗸 𝗶𝗻 𝘁𝗵𝗲 𝗿𝗲𝗮𝗹 𝘄𝗼𝗿𝗹𝗱: ⬇️ 1. 𝗔𝗴𝗲𝗻𝘁 𝗱𝗲𝘀𝗶𝗴𝗻 ≠ 𝗷𝘂𝘀𝘁 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 ➜ It’s not about clever prompts. It’s about building structured workflows — where the agent can reason, act, reflect, retry, and escalate. Think of agents like software components: stateless functions won’t cut it. 2. 𝗠𝗲𝗺𝗼𝗿𝘆 𝗶𝘀 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 ➜ The way you manage and pass context determines how useful your agent becomes. Using summaries, structured files, project overviews, and scoped retrieval beats dumping full files into the prompt window. 3. 𝗣𝗹𝗮𝗻𝗻𝗶𝗻𝗴 𝗶𝘀𝗻’𝘁 𝗼𝗽𝘁𝗶𝗼𝗻𝗮𝗹 ➜ You can’t expect an agent to solve multi-step problems without an explicit process. Patterns like plan > execute > review, tool use when stuck, or structured reflection are necessary. And they apply to all models, not just Claude. 4. 𝗥𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝗮𝗴𝗲𝗻𝘁𝘀 𝗻𝗲𝗲𝗱 𝗿𝗲𝗮𝗹-𝘄𝗼𝗿𝗹𝗱 𝘁𝗼𝗼𝗹𝘀 ➜ Shell access. Git. APIs. Tool plugins. The agents that actually get things done use tools — not just language. Design your agents to execute, not just explain. 5. 𝗥𝗲𝗔𝗰𝘁 𝗮𝗻𝗱 𝗖𝗼𝗧 𝗮𝗿𝗲 𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀, 𝗻𝗼𝘁 𝗺𝗮𝗴𝗶𝗰 𝘁𝗿𝗶𝗰𝗸𝘀 ➜ Don’t just ask the model to “think step by step.” Build systems that enforce that structure: reasoning before action, planning before code, feedback before commits. 6. 𝗗𝗼𝗻’𝘁 𝗰𝗼𝗻𝗳𝘂𝘀𝗲 𝗮𝘂𝘁𝗼𝗻𝗼𝗺𝘆 𝘄𝗶𝘁𝗵 𝗰𝗵𝗮𝗼𝘀 ➜ Autonomous agents can cause damage — fast. Define scopes, boundaries, fallback behaviors. Controlled autonomy > random retries. 7. 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝘃𝗮𝗹𝘂𝗲 𝗶𝘀 𝗶𝗻 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 ➜ A good agent isn’t just a wrapper around an LLM. It’s an orchestrator: of logic, memory, tools, and feedback. And if you’re scaling to multi-agent setups — orchestration is everything. Check the comments for the original material! Enjoy! Save 💾 ➞ React 👍 ➞ Share ♻️ & follow for everything related to AI Agents!

AI security/securing the use of AI is going to kill me. I use Claude Code almost daily. It's a problem.... Here's what I have to change AGAIN this week. Security researcher Ari Marzuk disclosed 30+ vulnerabilities across AI coding tools. Cursor. GitHub Copilot. Windsurf. Claude Code. All of them. He called it IDEsaster. The attack chain includes prompt injection, hijacking LLM context, and auto-approved tool calls executing without permission. Then, legitimate IDE features are weaponized for data exfiltration and RCE. Your .env files. Your API keys. Your source code. Accessible through features you thought were safe. Most studies I read claim that around 85% of developers now use AI coding tools daily. Most have no idea their IDE treats its own features as inherently trusted. 𝗦𝗼... 𝗮𝗳𝘁𝗲𝗿 𝗿𝗲𝘃𝗶𝗲𝘄𝗶𝗻𝗴 𝗔𝗿𝗶'𝘀 𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵, 𝗵𝗲𝗿𝗲'𝘀 𝗜 𝘄𝗶𝗹𝗹 𝗯𝗲 𝗱𝗼𝗶𝗻𝗴... Be warned: All this is SO much easier said than done! Audit every MCP server connection. Checked for tool poisoning vectors where legitimate tools might parse attacker-controlled input from GitHub PRs or web content. Removed servers I couldn't verify. Disabled auto-approve for file writes. The attack chains weaponize configuration files and project instructions like .claude/settings.json and CLAUDE.md. One malicious write to these files can alter agent behavior or achieve code execution without additional user interaction. Move all credentials to a secrets manager. No .gitignored .env files in agent-accessible directories. API keys live in 1Password CLI. Environment variables inject at runtime through a wrapper script the LLM never sees. Start running Claude Code in isolated containers. Mounted volumes limited to specific project directories. No access to ~/.ssh, ~/.aws, or ~/.config. If the agent gets compromised, blast radius stays contained. Enable all security warnings. Claude Code added explicit warnings for JSON schema exfiltration and settings file modifications. These exist because Anthropic knows the attack surface. Add pre-commit hooks for hidden characters. Prompt injections hide in pasted URLs, READMEs, and file names using invisible Unicode. Flag non-ASCII characters in any file the agent might ingest. The fix isn't to stop using AI coding tools. The fix is to stop trusting them implicitly. What controls do you have for AI tools with write access to your codebase? 👉 Follow for more AI and cybersecurity insights with the occasional rant #AISecurity #DevSecOps

Developers want to create solutions. Not port Java 11 to Java 17. The real opportunity with AI isn't about chasing the latest trend. It's about removing the undifferentiated heavy lifting that keeps teams from doing their best work. The latest research on Amazon Science validates this approach. Using our cost-to-serve-software framework (CTS-SW), teams that identified specific challenges before adopting AI tools cut costs by 15.9% year-over-year. They deployed more frequently and reduced manual interventions by 30.4%. And here's what really matters. Team velocity became the strongest predictor of cost efficiency in software development. This isn't just about AI. It's about focusing on the right problems first. Read the research here: https://lnkd.in/eCdd3wxz Insights from Jim Haughwout here: https://lnkd.in/egMCX6qe Now, go build!

Our frontend builds crossed 20 minutes. The obvious move was to rip out Webpack for something faster. We didn't. Before touching a single line of config, we profiled the entire pipeline. Webpack's ProgressPlugin turned up something we didn't expect — one plugin, Terser, was eating 13+ minutes of every build. Webpack wasn't the bottleneck. JavaScript minification was. 🔍 That one number changed the whole plan. We kept Webpack. Replaced Babel with SWC. Swapped Terser for esbuild. Moved CSS optimisation to LightningCSS. Parallelised compilation across cores with thread-loader. ⚙️ Fixed a hidden bottleneck too — AWS CodeArtifact tokens were re-authenticating every 12 hours and quietly busting our Docker cache. Restructured the Dockerfile into layers that actually cache. 🐳 20 minutes to 2 minutes. Cold build ~90% faster. Incremental ~95% faster. Across 20 production apps, 600+ PRs a month, 5,000+ CI runs. ⚡ No migration. No four-week rewrite. No new bundler to debug for the next year. The real lesson wasn't about tooling. It was that we almost skipped measurement and went straight to migration — the industry default. Glad we didn't. 💡 Full breakdown — the Speed Measure Plugin data, the pnpm switch, the exact Dockerfile changes — link in the first comment. 👇 Really proud of what our engineering team pulled off here. Worth the read. 🫡 Zepto Zepto Tech #ZeptoTechXPress #ZeptoEngineering

MCP is an MVP if you are exploring ways to supercharge your AI workflows. I am very impressed by the MCP (Model Context Protocol) architecture and proud of the way we have embraced it at Visa to accelerate our GAI work. MCP is an open standard, introduced by Anthropic. It acts like a universal connector, seamlessly linking AI applications to external tools, data, and services. Think of it as Bluetooth for AI – enabling plug and play integrations without multiple, messy connections and custom code.   For companies embracing the power of GAI, MCP is a dream come true. It eliminates the headache of building bespoke API integration for every tool, letting AI agents access resources like file systems, wikis, shared drives, databases etc in real time. This means your AI can pull custom data, automate tasks or analyze reports instantly. As an early adopter, we are already using MCP to streamline workflows and with 1000s of community built MCP servers, the eco system is exploding.   My advice to those beginning their MCP journey – start small. Identify a repetitive task (like updating CRM records or generating analysis). Setup an MCP server for your tool or service (many are prebuilt), connect it to your AI client and watch the magic happen. Experiment, scale, and explore the open-source MCP community for inspiration. Once you start using MCP, you will see a step function increase in your innovation velocity.

𝗪𝗵𝗮𝘁'𝘀 𝘁𝗵𝗲 𝗺𝗮𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝘃𝗶𝘁𝘆 𝗸𝗶𝗹𝗹𝗲𝗿 𝗳𝗼𝗿 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀? Context switching. You send a colleague a "quick" Slack message. Takes you 𝟱 𝘀𝗲𝗰𝗼𝗻𝗱𝘀, but it costs them 𝟮𝟯 𝗺𝗶𝗻𝘂𝘁𝗲𝘀 to get back into deep focus. Now imagine this happening 5-10 times a day. Your best engineers aren't shipping slow. We keep breaking their flow. It takes about 𝟭𝟱 𝗺𝗶𝗻𝘂𝘁𝗲𝘀 of uninterrupted work to reach flow state. One notification can break it, even if the developer never opens it. Here is what helps: - 𝗗𝗲𝗳𝗮𝘂𝗹𝘁 𝘁𝗼 𝗮𝘀𝘆𝗻𝗰. Not everything needs an instant reply - 𝗕𝗹𝗼𝗰𝗸 𝗳𝗼𝗰𝘂𝘀 𝘁𝗶𝗺𝗲. Protect 2-4 hours for deep work daily - 𝗕𝗮𝘁𝗰𝗵 𝗾𝘂𝗲𝘀𝘁𝗶𝗼𝗻𝘀. Combine five scattered pings into one message - 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁 𝗮𝗻𝘀𝘄𝗲𝗿𝘀. If it's asked twice, write it down once One team I worked with blocked focus time for a month. Story completion went up 𝟯𝟱%. Bug reports dropped 𝟮𝟴%. Stop treating your team's focus like it's free. It's the most expensive resource you have. 👉 Learn more about it: https://lnkd.in/dwi2XbXG

I used to think my portfolio had to impress other designers. So I filled it with sleek mockups, polished animations, and endless case studies. It looked beautiful...But it didn’t land me clients. Why? Because clients don’t hire you for aesthetics. They hire you for outcomes. 🚫 Too many portfolios still look like it’s 2015: → Pretty mockups → Trendy layouts → 10-second Behance loops But here’s the hard truth: Clients don’t care how cool it looks. They care what it does. 💡 Ask yourself: → Does my portfolio solve real business problems? → Am I showing results or just visuals? → Is it written for clients or for other creatives? What actually works in 2025: ✅ Highlight before/after results (data if possible) ✅ Explain your thinking, not just your tools ✅ Tailor your portfolio to your ideal client, not your peers Because great design isn’t just about craft It’s about clarity, strategy, and trust. ✨ Your portfolio shouldn’t be a gallery. It should be a sales tool. One that shows the value you bring, not just the vibe. 💬 Got a portfolio tip that worked for you? Drop it in the comments, let’s help each other grow. 📌 Save this if you’re about to redesign yours. It’s not about looking good. It’s about landing the right kind of work.