Software Development

“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]

If you’re a 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿, 𝗰𝗹𝗼𝘂𝗱 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿, 𝗗𝗲𝘃𝗢𝗽𝘀 𝘀𝗽𝗲𝗰𝗶𝗮𝗹𝗶𝘀𝘁, 𝗔𝗜 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿, or just starting your tech journey, 𝘆𝗼𝘂 𝘀𝗵𝗼𝘂𝗹𝗱 𝗯𝗲 𝗰𝗼𝗺𝗳𝗼𝗿𝘁𝗮𝗯𝗹𝗲 𝘄𝗶𝘁𝗵 𝗲𝘀𝘀𝗲𝗻𝘁𝗶𝗮𝗹 𝗟𝗶𝗻𝘂𝘅 𝗰𝗼𝗺𝗺𝗮𝗻𝗱𝘀.  Here’s why Linux dominates the tech world:  ✅ 𝟵𝟳% of the top 1 million web servers run on Linux   ✅ Powers 𝗺𝗼𝘀𝘁 𝗼𝗳 𝘁𝗵𝗲 𝘄𝗼𝗿𝗹𝗱’𝘀 𝘁𝗼𝗽 𝟱𝟬𝟬 𝘀𝘂𝗽𝗲𝗿𝗰𝗼𝗺𝗽𝘂𝘁𝗲𝗿𝘀   ✅ Forms the backbone of 𝗮𝗹𝗹 𝗺𝗮𝗷𝗼𝗿 𝗰𝗹𝗼𝘂𝗱 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝗿𝘀   ✅ Android (billions of devices) runs on the 𝗟𝗶𝗻𝘂𝘅 𝗸𝗲𝗿𝗻𝗲𝗹   ✅ Most 𝗗𝗲𝘃𝗢𝗽𝘀 & 𝗔𝗜 𝘁𝗼𝗼𝗹𝘀 are designed for Linux  𝗧𝗵𝗲 𝗟𝗶𝗻𝘂𝘅 𝗙𝗶𝗹𝗲 𝗦𝘆𝘀𝘁𝗲𝗺 – 𝗪𝗵𝗮𝘁 𝗬𝗼𝘂 𝗡𝗲𝗲𝗱 𝘁𝗼 𝗞𝗻𝗼𝘄   Understanding these core directories will set you up for success:  📂 /𝗯𝗶𝗻 – Essential system commands   📂 /𝗯𝗼𝗼𝘁 – Boot files for system startup   📂/𝗱𝗲𝘃 – Device files (hardware access)   📂 /𝗲𝘁𝗰 – Configuration files (the system’s control center)   📂/𝗵𝗼𝗺𝗲 – Your personal user space   📂 /𝗹𝗶𝗯 – Shared system libraries   📂 /𝘃𝗮𝗿 – Logs & variable files   📂 /𝘂𝘀𝗿 – Installed programs   📂 /𝘁𝗺𝗽 – Temporary files  𝗗𝗮𝗶𝗹𝘆 𝗟𝗶𝗻𝘂𝘅 𝗖𝗼𝗺𝗺𝗮𝗻𝗱𝘀 𝗬𝗼𝘂’𝗹𝗹 𝗨𝘀𝗲   🖱️ 𝚌𝚍 – Change directory   📂 𝚕𝚜 – List files & directories   📁 𝚖𝚔𝚍𝚒𝚛 – Create a new directory   📄 𝚌𝚙 – Copy files   🚀 𝚖𝚟 – Move/rename files   🗑️ 𝚛𝚖 – Remove files (handle with care!)  ✅ 𝗡𝗘𝗩𝗘𝗥 blindly copy-paste commands (especially with 𝚜𝚞𝚍𝚘)   ✅ Understand 𝗽𝗲𝗿𝗺𝗶𝘀𝘀𝗶𝗼𝗻𝘀 before making changes   ✅ Learn to 𝗿𝗲𝗮𝗱 𝗹𝗼𝗴𝘀 (`/var/log`) to troubleshoot issues   ✅ 𝗠𝗮𝘀𝘁𝗲𝗿 𝗼𝗻𝗲 𝘁𝗲𝘅𝘁 𝗲𝗱𝗶𝘁𝗼𝗿 (`vim` or 𝚗𝚊𝚗𝚘)   ✅ Keep your 𝗵𝗼𝗺𝗲 𝗱𝗶𝗿𝗲𝗰𝘁𝗼𝗿𝘆 𝗼𝗿𝗴𝗮𝗻𝗶𝘇𝗲𝗱 for efficiency  𝗛𝗼𝘄 𝘁𝗼 𝗚𝗲𝘁 𝗦𝘁𝗮𝗿𝘁𝗲𝗱 𝘄𝗶𝘁𝗵 𝗟𝗶𝗻𝘂𝘅 𝗧𝗼𝗱𝗮𝘆   📌 Install Linux in a 𝗩𝗠 (𝗩𝗶𝗿𝘁𝘂𝗮𝗹 𝗠𝗮𝗰𝗵𝗶𝗻𝗲)   📌 Use 𝗯𝗮𝘀𝗶𝗰 𝗰𝗼𝗺𝗺𝗮𝗻𝗱𝘀 𝗱𝗮𝗶𝗹𝘆   📌 Read 𝗺𝗮𝗻 𝗽𝗮𝗴𝗲𝘀 (`man ls`, 𝚖𝚊𝚗 𝚌𝚙 … they’re your best friend)   📌 𝗕𝗿𝗲𝗮𝗸 𝘁𝗵𝗶𝗻𝗴𝘀 (𝗶𝗻 𝗮 𝘁𝗲𝘀𝘁 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁) – then 𝗳𝗶𝘅 𝘁𝗵𝗲𝗺 (best way to learn!)  🔹 𝗜𝗻 𝗮 𝗰𝗹𝗼𝘂𝗱-𝗻𝗮𝘁𝗶𝘃𝗲 𝘄𝗼𝗿𝗹𝗱, 𝗟𝗶𝗻𝘂𝘅 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝗮𝗻 𝗢𝗦—𝗶𝘁’𝘀 𝘁𝗵𝗲 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻 𝗼𝗳 𝗺𝗼𝗱𝗲𝗿𝗻 𝘁𝗲𝗰𝗵.    The sooner you get comfortable with it, the further you’ll go in your career!  

AI Agent interaction is going to be one of the most interesting software interoperability paradigms of the future. Inevitably, no one software system contains all the knowledge or information to perform all the tasks that an enterprise or users needs. This means we’ll need AI Agents to coordinate and do work together. Since the influx of modern APIs with the rise of cloud and SaaS, software interoperability has been a relatively solved problem. Most modern software offers a set of APIs and we know how to get our technologies to talk to each other in deterministic ways. AI Agents, on the other hand, offer a new era in web interoperability to coordinate non-deterministic work. No longer is one system making precise calls to another system, but instead we’ll have AI Agents that process requests from a user (or system), farm out requests to Agents in other systems as relevant, then return an answer or result back to the user with further judgment applied. For instance, you may ask Salesforce a question about a customer and an Agent will combine in an answer from Agents that review contracts in Box or billing info in Stripe. Or, you’re onboarding as a new employee and you ask an Agent a question in ServiceNow, which fans out to HR documentation in Box or data in Workday. Or you want to build software with Replit or Devin, and the Agent talks to Agents in Box for product specs, project plans in Asana, or design assets in Figma. Agents in this case would operate in a very similar fashion to how another human would interact between different software tools. Doing a search between different apps, reviewing the data, and then collating it back in a final format. Of course there are many open questions in this new era of software. Will Agent interoperability work on a bidirectional way, or will one Agent always take the lead? How do we seamlessly handle permission access between systems What is the business and financial model of a world with Agents running around doing work for us between systems? How do we ensure accuracy on results and not have incremental hallucination or mistakes at each step? As an industry, we’ll have to work to make this insanely seamless for customers, but definitely one of them most exciting paradigm shifts.

Yesterday, a reel flooded my DMs, featuring someone boasting about a fabricated production issue as if it were a badge of honor. For any college student or aspiring developer reading this, here’s a glimpse of how a typical production release works in a large organization like Amazon, especially for a customer-facing feature: - Feature Flags: Any new feature or change you push is almost always behind a feature flag. If the flag is enabled, the new code executes; otherwise, it defaults to the existing behavior. - Bug Bash: The team conducts a rigorous bug bash to identify and fix any glaring issues. - Quality Assurance (QA): Dedicated QA engineers test the feature across all critical user journeys, ensuring stability and functionality. - Gradual Rollout: The production rollout is phased: • Initially, only 1% of users experience the feature. • If no critical bugs are reported, the rollout progresses to a higher percentage (e.g., 10%, then 50%, and finally 100%). • In some organizations, this process involves releasing to alpha, beta, and general users, which follows the same principle. - Logs and Deployment Tracking: Every change or deployment is logged. This eliminates any ambiguity—no one needs to call or ask if a deployment occurred. A simple search in the deployment history provides all the details. - On-Call and Incident Management: In the event of an issue, on-call developers are the first to respond. If the new feature is causing the problem, they can disable the feature flag, instantly rolling back to the previous stable state. Key Takeaway: A proper production release is a systematic, collaborative, and well-monitored process. It’s not a playground for recklessness or boasting about mishandled issues. Be proud of delivering quality, not chaos. Keep learning, stay humble, and remember—the goal is to solve real problems, not create them. #striver #engineering

🔧 Why C Still Reigns Supreme in the World of Systems and Embedded Development Despite the flood of modern programming languages, C is not going anywhere and for very good reasons. If you're an aspiring embedded systems engineer, systems programmer, compiler developer, or even working in IoT, automotive, aerospace, medical devices, robotics, OS kernels, or performance-critical AI systems—you need to know C. Not just surface-level, but deep—pointer-arithmetic, memory models, linker behavior, and beyond. 💡 Why Is C Still So Important? ✅ Foundational to Modern Software C forms the core of modern operating systems, device drivers, microcontroller firmware, networking stacks, and more. Linux, Windows kernel components, embedded RTOSs, and most bootloaders are all written in C. ✅ Portability + Performance With its ability to compile directly to machine-level instructions and fine-grained control over memory and CPU usage, C enables highly efficient and deterministic code—crucial in embedded and real-time systems. ✅ Hardware-Level Control C gives you direct access to registers, memory addresses, and low-level operations. That’s why ARM Cortex-M, AVR, STM32, PIC, and even bare-metal RISC-V systems are taught and programmed in C. ✅ Toolchain Ecosystem Toolchains like GCC, IAR, Keil, Clang, and GHS are optimized for C. Most debugging tools, static analyzers, and safety certification tools are designed with C in mind—especially in MISRA, AUTOSAR, ISO 26262, and DO-178C compliant industries. ✅ Ubiquity in Industry Interviews Whether it's NXP, Infineon, Qualcomm, Intel, or Bosch—C questions dominate embedded interviews. From bit manipulation to memory maps to ISRs, you can’t escape it. 📍 Where Is C Used? Microcontrollers & Bare Metal Programming (e.g., STM32, AVR, MSP430) Kernel and OS Development (Linux Kernel, Windows NT) Drivers and Firmware (USB, UART, I2C, SPI, CAN) IoT Platforms (Contiki, RIOT OS, Zephyr) Automotive Software (AUTOSAR BSW modules) Medical and Aerospace Systems (Safety-critical environments) Compiler and Interpreter Backends Network Stack and Protocol Implementation 🔍 How Much C Should You Know? ➡️ Enough to design your own OS kernel modules and bootloaders. But practically, you should master: 🧠 Pointers and Memory Management Pointer arithmetic, const correctness, double/triple pointers Dynamic/static memory regions (stack/heap/data/bss) 🛠️ Bitwise Operations & Memory Mapping Efficient register-level manipulation (critical for peripheral drivers) 🔁 Control Flow, Optimization, and Inlining Loop unrolling, reducing function call overhead 📎 Linkers, Compilers, and Makefiles Understand .data, .bss, heap, and stack behavior Learn gcc, ld, nm, objdump and make 🧪 Unit Testing and Safety Coding Standards CppUTest and MISRA C compliance 🧬 Interrupts and ISRs Handling concurrency, atomic operations, volatile, and memory barriers 💻 Toolchain Knowledge Cross-compilation, flashing, and JTAG/SWD debugging #CProgramming

Dear Software Engineers, If your app serves 10 users → a single server and REST API will do If you’re handling 10M requests a day → start thinking load balancers, autoscaling, and rate limits /— If one developer is building features → skip the ceremony, ship and test manually If 10 devs are pushing daily → invest in CI/CD, testing layers, and feature flags /— If your downtime just breaks one page → add a banner and move on If your downtime kills a business flow → redundancy, health checks, and graceful fallbacks are non-negotiable /— If you're just consuming APIs → learn how to handle 400s and 500s If you're building APIs for others → version them, document them, test them, and monitor them /— If your product can tolerate 3s of lag → pick clarity over performance If users are waiting on each click → profiling, caching, and edge delivery are part of your job /— If your data fits in RAM → store it in memory, use simple maps If your data spans terabytes → indexing, partitioning, and disk I/O patterns start to matter /— If you're solo coding → naming things poorly is just annoying If you're on a growing team → naming things poorly is a ticking time bomb /— If you're fixing bugs once a week → logs and console prints might do If you're running production → you need structured logs, tracing, alerts, and dashboards /— If your deadlines are tight → write the simplest code that works If your code is expected to last → design for readability, testability, and change /— If you work alone → "it works on my machine" might be fine If you're in a real team → reproducible builds and shared dev setups are your baseline /— If your app is new → move fast, clean up later If your app is in maintenance hell → you now pay interest on every rushed decision People think software engineering is just about building things. It’s really about: – Knowing when not to build – Being okay with deleting good code – Balancing tradeoffs without always having all the data The best engineers don’t just ship fast. They build systems that are safe to move fast on top of.

Today, I witnessed my team lead interviewing a Full-Stack Web Developer with 2 years of experience, and I observed some interesting insights. The interview started with basic technical questions, which the candidate answered well. Then, my team lead gave him a coding task: 👉 "Write a function that removes duplicate values from a nested array while preserving its structure (PHP)." The candidate struggled and couldn’t solve it. So, my lead gave him another task: 👉 "Write a function that groups an array of associative arrays based on a specific key." Again, he couldn’t solve it. At this point, he admitted: "I don’t always have syntax and logic rules memorized, as I usually rely on resources like Stack Overflow and ChatGPT. Could you assign me a real-world task instead?" Here,I decided to step in. Since I was working on WooCommerce project, I gave him this challenge: 💡 "Implement a functionality where a logged-in user gets a 15% discount if they place two orders in a single day." We allowed him to use Google, ChatGPT, or any other resources. To our surprise, within 1.5 hour, he understood WooCommerce functionality, analyzed the existing code, and successfully implemented the feature. ✨ We ended up hiring him! ✨ Key Takeaway Many traditional interview techniques overemphasize logical puzzles and syntax-heavy questions, yet modern developers approach problem-solving differently. Rather than memorizing solutions, they adapt, learn, and implement on the spot using the tools and resources available to them. 💡 Instead of testing how well candidates remember syntax, we should focus on how effectively they apply problem-solving skills to practical challenges. What’s your take on this? Let’s discuss in the comments! 👇 #HiringTechTalent #TechCommunity #WhatDoYouThink

The 10 Rules NASA Swears By to Write Bulletproof Code: 0. Restrict to simple control flow ↳ No goto, setjmp, longjmp, or recursion. Keep it linear and predictable. This ensures your code is easily verifiable and avoids infinite loops or unpredictable behavior. 1. Fixed loop bounds ↳ Every loop must have a statically provable upper bound. No infinite loops unless explicitly required (e.g., schedulers). This prevents runaway code and ensures bounded execution. 2. No dynamic memory allocation after initilization ↳ Say goodbye to malloc and free. Use pre-allocated memory only. This eliminates memory leaks, fragmentation, and unpredictable behavior. 3. Keep functions short ↳ No function should exceed 60 lines. Each function should be a single, logical unit that’s easy to understand and verify. 4. Assertion density: 2 per function ↳ Use assertions to catch anomalous conditions. They must be side-effect-free and trigger explicit recovery actions. This is your safety net for unexpected errors. 5. Declare data at the smallest scope ↳ Minimize variable scope to prevent misuse and simplify debugging. This enforces data hiding and reduces the risk of corruption. 6. Check all function returns and parameters ↳ Never ignore return values or skip parameter validation. This ensures error propagation and prevents silent failures. 7. Limit the preprocessor ↳ Use the preprocessor only for includes and simple macros. Avoid token pasting, recursion, and excessive conditional compilation. Keep your code clear and analyzable. 8. Restrict pointer use ↳ No more than one level of dereferencing. No function pointers. This reduces complexity and makes your code easier to analyze. 9. Compile with all warnings enabled ↳ Your code must be compiled with zero warnings in the most pedantic settings. Use static analyzers daily to catch issues early. Some of these rules can be seen as hard to follow, but you can't allow room for error when lives are at stake. Which ones are you still applying? #softwareengineering #systemdesign ~~~ 👉🏻 Join 46,001+ software engineers getting curated system design deep dives, trends, and tools (it's free): ➔ https://lnkd.in/dCuS8YAt ~~~ If you found this valuable: 👨🏼💻 Follow Alexandre Zajac 🔖 Bookmark this post for later ♻️ Repost to help someone in your network

Reflecting on my conversation with CNBC’s Carolin Roth at the World Economic Forum, I was struck by how quickly the conversation around enterprise software has evolved. There is a lot of attention on what AI can do. We focused instead on what actually drives value: disciplined execution. I believe AI only creates lasting advantages when it is built into real workflows, connected to proprietary data, and scaled responsibly within operating businesses. What feels increasingly clear is that this is not about replacing software. It is about advancing it. We see the next phase as the rise of Agentic Enterprise Solutions, trusted systems that, in our view, move from supporting work to carrying it out and can deliver more predictable and accountable results. As AI moves into regulated and mission-critical environments, context and trust become essential. We believe the platforms that pair deep domain expertise and embedded workflows with the ability to innovate quickly are positioned to lead. At Vista Equity Partners, we see this as part of software’s long trajectory of growth. The agentic era is here. As with every major technology shift, the winners will be defined by how well they execute. https://bit.ly/4tjKSiO

A free ~64 page guide to engineering reliable AI agents! If you are a software engineer, you have likely already hit the "prototype plateau." You can get an LLM to answer a question or build an MVP, but getting it to reliably execute a 5-step agent workflow without hallucinating or looping is a harder engineering problem. We built the "Startup Technical Guide: AI Agents" to solve this. This is a manual for the cognitive architecture required to move from an agent demo to a deployed agent workforce. Why this matters for your stack: We move beyond simple "chatbot" patterns and dive into how to build agents that actually do work - like an agent for support or research, that monitors cloud logs and autonomously restarts a Kubernetes pod, or a support agent that executes refunds with ACID-compliant audit trails. Inside the guide: - The Toolkit: When to use the Agent Development Kit (ADK) for code-first control versus managed runtimes. - Architecture: How to implement ReAct loops (Reason + Action) so your agent can plan, act, and observe results before proceeding. - Grounding: Moving beyond basic RAG to Agentic RAG, where the model actively formulates search strategies rather than just passively receiving context. - AgentOps: How to implement trajectory evaluation. Don't just "vibe check" the output; trace the reasoning steps and unit test your tools. 🚀 Just launched: Enhanced tool governance To support this shift to production, we also just announced a massive update to "Vertex AI Agent Builder: the integration of the Cloud API Registry" For engineers, this solves the "duplicate work" problem. Instead of every developer rewriting the same tool definitions for BigQuery or Google Maps, we now provide a private registry. Admins can curate approved tools (including custom MCP servers via Apigee), and you can simply instantiate an ApiRegistry object in the ADK to pull them into your agent. It secures the supply chain and speeds up dev time. We also rolled out native state recovery in the ADK (no more lost context if a conversation crashes) and support for Gemini 3 Pro. The ecosystem is maturing fast. Grab the guide and start building. #ai #programming #softwareengineering #agents