Enhancing Developer Experience

Last month, engineering leads at Duolingo held our first “engineerication.” (I got the idea from Stripe.) Basically, we took a week off from our regular jobs to sit together and code in order to see what our engineers do daily, get back into the tech stack to see what can be improved. 👩💻 Turns out, a lot has changed in the years since I last wrote a line of code 😅Some things have gotten much easier. Codespaces, for example, allows engineers to easily create a coding environment in the cloud instead of on their local machines. And GitHub Copilot auto-suggests chunks of code. But there were 3 big takeaways I had for how we can improve our engineers’ experiences: 1. On the first day, I set out to do a few small code changes. But as a new engineer, you can’t just sit down and make a change immediately, even a tiny one. You have to set up your environment and figure out where the code needs to go. Then you have to build the code, test it, get it reviewed, and push it live to production. All of this takes time—sometimes, too much time. I want to make it easy for new software engineers to be productive right away without having to set up their development environment or having to learn a lot of arcane tools, processes, and magical incantations. 2. When I started at Duolingo nine years ago, we had a few GitHub repositories. Now we have dozens of microservices. This means that even a small code change may require updates to several repositories. If you’re not regularly working in a given repo, this is much harder, especially if it’s one that your team doesn't own. More standardization is needed to make it easier to code across our various microservices and client repos (we’re starting to do this, but more can be done!) 3. Code review turnaround time slowed us down. We averaged about a 24-hour turnaround, but when making atomic (easily revertable) pull requests, lots of PRs stack up and eventually lead to merge conflicts, etc. In practice, I could see engineers cutting their turnaround time by making PRs that are less atomic, which leads to messier reverts and a harder time diagnosing bugs. Whenever software engineers are tempted to take shortcuts because the current process is too slow or painful, that’s an opportunity for improvement. Overall, taking a week to go hands-on with the code is a great way to build better processes and teams. It was an incredibly valuable week that helped us visualize the steps we can take to remove pain points and speed up some unnecessarily slow processes. 🐢 (One more learning: Next time, I’m going to invite one of our software engineers to pair program with me 😅) Help us develop new products and processes! We're hiring: https://lnkd.in/eSJYjYPG #engineering #processimprovement #leadershipidea

Building an API that empowers developers and fosters a thriving ecosystem around your product takes intentionality. Here are 11 guiding principles to design and create robust APIs: 1. 𝗦𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗨𝘀𝗲𝗿:  Identify your target developers and understand their needs. What tasks will they be using the API for? Design with their experience in mind. 2. 𝗖𝗹𝗲𝗮𝗿 𝗮𝗻𝗱 𝗖𝗼𝗻𝗰𝗶𝘀𝗲 𝗗𝗲𝘀𝗶𝗴𝗻:  Strive for simplicity and consistency in your API's design. Use well-defined resources, intuitive naming conventions, and a consistent HTTP verb usage (GET, POST, PUT, DELETE). 3. 𝗩𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴:  Plan for future changes with a well-defined versioning strategy. This allows developers to adapt to updates smoothly and prevents breaking changes. 4. 𝗗𝗲𝘁𝗮𝗶𝗹𝗲𝗱 𝗗𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻: Invest in comprehensive and up-to-date documentation. Include clear explanations of endpoints, request/response formats, error codes, and example usage. 5. 𝗘𝗿𝗿𝗼𝗿 𝗛𝗮𝗻𝗱𝗹𝗶𝗻𝗴:  Implement a robust error handling system. Provide informative error messages with clear explanations and HTTP status codes for easy debugging. 6. 𝗥𝗮𝘁𝗲 𝗟𝗶𝗺𝗶𝘁𝗶𝗻𝗴 𝗮𝗻𝗱 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆:  Protect your API from abuse and ensure data security. Implement rate limiting to prevent overwhelming your servers and enforce strong authentication and authorization mechanisms. 7. 𝗧𝗲𝘀𝘁𝗶𝗻𝗴 𝗶𝘀 𝗖𝗿𝘂𝗰𝗶𝗮𝗹:  Thoroughly test your API before exposing it to developers. Use unit testing, integration testing, and automated testing tools to ensure functionality and reliability. 8. 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗮𝘁𝗶𝗼𝗻:  Focus on optimizing API performance. Implement caching mechanisms, minimize data transfer sizes, and choose efficient data formats (JSON, XML). 9. 𝗔𝗻𝗮𝗹𝘆𝘁𝗶𝗰𝘀 𝗮𝗻𝗱 𝗠𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴:  Track API usage and gather insights into developer behavior. Analyze data to identify areas for improvement and potential new features. 10. 𝗖𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆 𝗘𝗻𝗴𝗮𝗴𝗲𝗺𝗲𝗻𝘁:  Foster a developer community around your API. Provide forums, discussions, and clear communication channels for feedback and support. 11. 𝗘𝘃𝗼𝗹𝘂𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁:  APIs are not static. Be prepared to iterate and evolve based on developer feedback and changing needs. Continuously improve your API to enhance its usefulness. By following these principles, you can design APIs that are not just functional, but also a joy to use for developers, ultimately leading to a more successful product and ecosystem. Have I overlooked anything? Please share your thoughts—your insights are priceless to me.

All people that manage software devs should contribute code. Full stop. "But managers should focus on people, not code!" "They'll be too rusty to contribute meaningfully." "There's not enough time in their schedule." "That's what we hire developers for!" Once a year, every engineering manager should land a small code change into production. Nothing complex - change a button color or tackle a tiny task from the sprint backlog. By going through this process, managers will experience firsthand: navigating your code base, dealing with environment setup, waiting for CI/CD pipelines, addressing code review feedback, fixing failing tests, and working with deployment processes. These small frustrations are your team's daily reality. Ever wonder why "simple changes" aren't so simple? When a manager experiences how a 5-line code change can take hours due to dependency issues, environment quirks, and proper testing, those estimation conversations take on new meaning. Suddenly, "Why can't we just..." transforms into "I understand why this takes time." If managers struggle with this exercise, they're not failing—they're finally feeling what their teams experience daily. No amount of status reports or retrospective meetings can replace the visceral understanding that comes from wrestling with merge conflicts or waiting anxiously for test results. This isn't about embarrassing them. It's about building genuine empathy through shared experience. I say turn this into a celebration! Make it a "Manager Shipping Day" with the team rallying around their leader. Order lunch, pair program, and cheer when that commit finally merges. The shared laughs over configuration struggles create will stronger bonds than any team happy hour. This isn't about shaming managers because they haven’t coded in many years. It's about creating mutual respect through shared challenges and victories. Like how Amazon encourages leaders to listen to customer service calls to truly understand customer pain points, engineering managers need to experience the developer journey firsthand. You can't fully empathize with your team's challenges when you're only discussing them in the abstract. Great leadership requires understanding the actual work experience of those you manage. Coding annually keeps managers connected to the practical realities their teams face daily. What's your take? Should they be required to code?

🔊Software engineering is dead. Long live software engineering. 🔊 OpenAI just launched Codex agents - cloud-based software agents that don’t just write code, they complete tasks. If you’re chronically online like me, your first reaction might’ve been an eye-roll.🙄 Another AI coding assistant? Get in line. For the last few years, AI tools for devs have fallen into 3 buckets: 1️⃣ Autocomplete tools like Copilot. Fast, helpful, but context-blind and execution-dumb. 2️⃣ Natural language code translators. Can explain or write snippets, but they can’t run anything. 3️⃣ Autonomous dev agents. Promising demos (Devin, Sweep), but not yet deployable at scale. Codex is different. It runs in a sandboxed execution environment, reads your repo, executes the task, validates results, and returns a diff. Not a suggestion - a deliverable. It introduces two primitives: ▶️ Code: Give it a scoped task. (“Add pagination to this table.”) ▶️ Ask: Query your repo. (“How is this error handled across routes?”) Each job runs independently, logs its actions, and returns outputs you can review, rerun, or roll back. This isn’t a tool. It’s a system. Pair that with OpenAI’s rumored acquisition of Windsurf - a company building AI-native IDEs and developer environments - and the picture sharpens: Codex handles execution. Windsurf handles integration. If Codex is the contractor, Windsurf is the construction site.Together, they’re going after the entire SDLC. For OpenAI, this both a defensive move (avoid becoming a commoditized model vendor) and an offensive one (own the agent runtime, IDE, and dev surface). So what does this mean for engineers? Not extinction, evolution. 🤔 Less typing. More thinking. From writing code → specifying behavior. From debugging syntax → debugging logic. 💀 Boilerplate gets eaten. Tests, scaffolds, YAML configs - agent territory now. The ladder for entry-level engineers just lost a few rungs. 💯 The new 10x engineer? A conductor. Not faster alone, but better at orchestrating agents and humans. Prompter, validator, architect. 🏗️ System design becomes the baseline. You’ll still need engineers - but they’ll need to think like staff engineers earlier, with deeper context and higher-leverage tasks. If you're wondering whether this replaces engineers, the answer is: highly unlikely. It just changes what they do, how they’re hired, and what “good” looks like. Every leap in developer productivity doesn’t shrink the workforce - it multiplies the software we write. AI doesn't kill software engineering, it just kills the illusion that writing the code was ever the hard part.

Want happy developers? Prioritize these 3 things. Flow. Feedback. Cognitive Load. A very insightful 2023 study published by the Association for Computing Machinery breaks optimal developer experience down into these three practical dimensions: 1. Flow state. Developers do their best work when they can get into the zone. Anything that creates interruptions means that they're taken out of flow state and unable to do their best problem solving. 2. Feedback loops. Devs like to have short feedback loops. Problem solving is inherently an iterative exercise and you want fast iterations. The faster you get feedback, the faster you can move onto the next iteration. Devs get frustrated if code is sitting there for weeks before moving into production. 3. Cognitive load. Even though a developers job is to code, there are many other things they have to deal with that's irrelevant to solving their code problem — e.g. learning the internals of Kubernetes or having to figure out a deployment script someone wrote 5 years ago. All of these things create cognitive load that slows them down. Agree/disagree? What other factors need to be highlighted? #DevelopersExperience #DevEx #Developer

Developer Experience (DevX) is critical for Platform Products If you're managing a platform product, know this: Developer Experience (DevX) isn't just an after-thought; it's essential. This was the lesson that I took away early on in my career, when I was caught off guard by the amount of Developer Experience work that I had to focus on working back then at #magento (a digital commerce platform) Here's why focusing on DevX should be a priority for every product manager dealing with platform products: 🔍 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗗𝗲𝘃𝗫: DevX is about creating a development environment that's not only efficient but also inspiring for developers. This means offering fast setup, seamless integration, and minimal maintenance overhead. The goal? To empower developers to focus more on innovation and less on overcoming technical hurdles. 🎯 𝗧𝗵𝗲 𝗜𝗺𝗽𝗼𝗿𝘁𝗮𝗻𝗰𝗲 𝗼𝗳 𝗗𝗲𝘃𝗫: In consumer products, subpar DevX might not directly affect the end user's interaction with the product. However, in platform products, developers are your end users. They are the ones who extend and enhance the platform's capabilities, directly impacting the end user's experience. Therefore, a stellar DevX can significantly influence their choice to adopt and advocate for your platform. 💡 𝗧𝗵𝗲 𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲: Platform products serve dual user groups—the developers who build on the platform and the end users who interact with the final products. Ensuring a superior DevX means these developers can efficiently create valuable applications that end users love, making your platform the preferred choice for innovation. Investing in Developer Experience isn't optional—it's crucial. A great DevX can be the deciding factor in the success of your platform, as it directly affects how developers perceive and interact with your technology. 🗣️ How do you enhance Developer Experience in your platforms? Have you noticed a shift in platform adoption or innovation as a result? Share your experiences and strategies below. 👇 #DeveloperExperience #PlatformProducts #ProductManagement #TechLeadership  #platformproductmanagement

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!

Want to build RAG apps and AI Agents? But your documents are a mess... I found a Python library that can transform any document into LLM-ready data. With just 3 lines of Python code. Here's what makes Docling special: It handles everything: ↳ PDFs with complex layouts ↳ Word documents ↳ PowerPoint slides ↳ Even scanned documents The best part? It's 100% opensource. It understands document structure like humans do: → Page layouts → Reading order → Table structures → Images and their context And it exports to formats your LLMs actually need: ↳ Clean HTML ↳ Structured Markdown ↳ JSON with embedded images Building AI agents? Docling integrates directly with LlamaIndex and LangChain. Working with scanned documents? Built-in OCR has got you covered. I've seen too many RAG projects fail because of messy document processing. That's why tools like this matter. Your LLM is only as good as the data you feed it. What's the biggest challenge you face when preparing documents for your RAG applications? Let me know in the comments below. P.S. I create AI tutorials and opensource them for free. Your 👍 like and ♻️ repost keeps me going. Don't forget to follow me Shubham Saboo for daily tips and tutorials on LLMs, RAG and AI Agents.

Still think your CI/CD pipeline is safe? Time to wake up! DevOps teams prioritize speed. Ship fast. Deploy often. Automate everything. But here’s the truth nobody wants to hear: Your pipeline is a direct line to production — and attackers know it. Why is it risky? • CI/CD tools (like Jenkins, GitLab, GitHub Actions) often hold secrets, SSH keys, cloud creds • Pipelines run with high privileges – often root, often unrestricted • A single vulnerable script or exposed token can lead to full compromise • Logs, artifact registries, and container images = goldmine for attackers • And guess what? Security is still an afterthought in too many teams What can you do to protect it? • Shift Left on Security – Integrate SAST/DAST/IaC scanning in every build – Fail builds on critical CVEs • Use Secrets Management – Stop hardcoding secrets in repos or pipeline variables – Use tools like Vault, AWS Secrets Manager, Doppler… • Implement Least Privilege in Your Pipelines – Don’t let pipelines deploy as root if they don’t need to – Use scoped service accounts, not blanket permissions • Connect Your Pipelines to the SOC – Feed CI/CD logs into your SIEM – Alert on anomalous build triggers, privilege escalation, or credential usage • Secure Your Build Agents & Containers – Harden runner environments – Don’t reuse agents across projects or tenants – Scan containers before pushing to registry Your pipeline isn’t just a toolchain — it’s your production supply line. Treat it like critical infrastructure. Secure it. Monitor it. Lock it down. #DevSecOps #CI_CD #SOC #Cybersecurity #ShiftLeft #DevOpsSecurity #SupplyChainSecurity

Want to Make Your RAG Application 10x Smarter? Retrieval-Augmented Generation (RAG) systems are powerful, however with the right strategies, you can turn them into precision tools. Here’s a breakdown of 10 expert-backed ways to optimize RAG performance: 1. 🔹Use Domain-Specific Embeddings Choose embeddings trained on your industry (like legal, medical, or finance) to improve semantic understanding and relevance. 2. 🔹Chunk Wisely Split documents into overlapping, context-rich chunks. Avoid mid-sentence breaks to preserve meaning during retrieval. 3. 🔹Rerank Results with LLMs Instead of relying only on top vector matches, rerank retrieved chunks using your LLM and a scoring prompt. 4. 🔹Add Metadata Filtering Use filters (like author, date, or doc type) to refine results before sending them to your language model. 5. 🔹Use Hybrid Search (Vector + Keyword) Combine the precision of keyword search with the flexibility of vector search to boost accuracy and recall. [Explore More In The Post] ✅ Use this checklist to fine-tune your RAG workflows, reduce errors, and deliver smarter, more reliable AI responses. #genai #artificialintelligence