Enhancing Developer Experience

CI/CD Pipeline for Machine Learning: A Comprehensive Guide I've created a visual breakdown of a modern ML CI/CD pipeline, demonstrating the three critical stages of ML model deployment: Step 1: Unit Tests - Feature Retrieval → Validation → Training → Evaluation → Validation → Handover - Each component undergoes rigorous unit testing to ensure individual functionality Step 2: Integration Tests - Introduces Feature Store and Model Registry - Tests interactions between components - Validates data flow and model transitions - Ensures seamless integration of the entire pipeline Step 3: Delivery - Production-ready pipeline with monitoring - Feature Store for consistent data management - ML Metadata Store for model tracking - Model Registry for version control - Orchestration and monitoring systems for reliability Key Benefits: • Ensures model reproducibility • Maintains quality through automated testing • Streamlines deployment process • Enables continuous monitoring and updates This pipeline architecture helps bridge the gap between ML development and production deployment, ensuring reliable and scalable ML systems.

Developer happiness is no soft metric; it has a direct impact on productivity and retention. Yet, many enterprises focus purely on output numbers, missing the deeper causes of disengagement. Unhappy developers can be around 31% less productive and are twice as likely to leave, with replacement costs running between £30K–£50K+. Despite this, few organisations routinely measure or prioritise developer happiness alongside established metrics like DORA and CORE 4. Here’s a practical approach that’s working for us: 🎯 Measure happiness alongside Core 4 & DORA using DX snapshot surveys, focus groups, and regular 1:1 conversations. This blends data with genuine sentiment. ⚙️ Prioritise fixes that matter most: reduce toil through automation, provide modern tooling, clarify career paths, and recognise genuine contributions. 🔄 Build a continuous feedback loop by identifying pain points, fixing what counts, measuring outcomes, and then adapting. ⚠️ Pushing for more output without supporting well-being often backfires, reducing overall efficiency. Our low attrition and strong culture at Tesco Bengaluru as reported in this article (https://lnkd.in/eED7uRkS) shows that investing in developer happiness delivers real, lasting value. It’s not about perks; it means giving developers autonomy, mastery, purpose, and psychological safety. As we develop our developer experience strategies globally, focusing on happiness as a leading indicator rather than an afterthought makes a real difference. Supporting our teams this way helps success come naturally. Well done to everyone contributing to this journey across Tesco Technology and beyond! Looking forward to continuing to learn and improve together. 🎉👏 #dx #tescotechnology #leadership #SoftwareEngineering #Technology #devex

“Developer productivity will be measured by the number of git commits per day” Thinking about this almost gets me so fired up that I can’t think straight. Replace “git commits” with “lines of code” - same thing. I had heard of this happening but each time it sounded more like an urban legend than reality. Until someone told me first hand that a manager at their workplace was thinking of implementing it. I told them to resign. Immediately. There is just no room for mincing words. If you’re considering this you should not be leading developers in any capacity and you should hire someone who knows what they’re doing. Any developer can commit as many commits as they need to to meet your metric. Every keystroke could be a git commit if they need it to be. Thousands of commits per day. Smart developers will even write an app that can automatically split a days work into many commits. Senior developers spend significant time preventing your project from failing. Sometimes that is with code, but often it’s meetings with other teams, helping guide other engineers away from disaster or designing architecture so that the system can scale appropriately. None of those activities are represented in git. However they are more critical to team productivity and project success than code output. Developers who bang out code without thinking do not usually arrive at the best, cheapest or fastest option. There are usually many potential ways to solve a problem and spending some time thinking about it is more likely to get better results. Thinking time and considering options are not represented in git. Hire leaders who understand what it takes to motivate software teams, support them when production explodes and what it takes to build a culture that grows high performing teams. Hire engineering leaders who know what productivity looks like, how it can be measured, and what needs to be changed to see it improve. Fire any leader that would use git commits or lines of code to measure productivity. If you don’t want to fire them, make sure they never step anywhere near a software team, or you may find many resignation letters in your inbox.

If you’re building with LLMs, these are 10 toolkits I highly recommend getting familiar with 👇 Whether you’re an engineer, researcher, PM, or infra lead, these tools are shaping how GenAI systems get built, debugged, fine-tuned, and scaled today. They form the core of production-grade AI, across RAG, agents, multimodal, evaluation, and more. → AI-Native IDEs (Cursor, JetBrains Junie, Copilot X) Modern IDEs now embed LLMs to accelerate coding, testing, and debugging. They go beyond autocomplete, understanding repo structure, generating unit tests, and optimizing workflows. → Multi-Agent Frameworks (CrewAI, AutoGen, LangGraph) Useful when one model isn’t enough. These frameworks let you build role-based agents (e.g. planner, retriever, coder) that collaborate and coordinate across complex tasks. → Inference Engines (Fireworks AI, vLLM, TGI) Designed for high-throughput, low-latency LLM serving. They handle open models, fine-tuned variants, and multimodal inputs, essential for scaling to production. → Data Frameworks for RAG (LlamaIndex, Haystack, RAGflow) Builds the bridge between your data and the LLM. These frameworks handle parsing, chunking, retrieval, and indexing to ground model outputs in enterprise knowledge. → Vector Databases (Pinecone, Weaviate, Qdrant, Chroma) Backbone of semantic search. They store embeddings and power retrieval in RAG, recommendations, and memory systems using fast nearest-neighbor algorithms. → Evaluation & Benchmarking (Fireworks AI Eval Protocol, Ragas, TruLens) Lets you test for accuracy, hallucinations, regressions, and preference alignment. Core to validating model behavior across prompts, versions, or fine-tuning runs. → Memory Systems (MEM-0, LangChain Memory, Milvus Hybrid) Enables agents to retain past interactions. Useful for building persistent assistants, session-aware tools, and long-term personalized workflows. → Agent Observability (LangSmith, HoneyHive, Arize AI Phoenix) Debugging LLM chains is non-trivial. These tools surface traces, logs, and step-by-step reasoning so you can inspect and iterate with confidence. → Fine-Tuning & Reward Stacks (PEFT, LoRA, Fireworks AI RLHF/RLVR) Supports adapting base models efficiently or aligning behavior using reward models. Great for domain tuning, personalization, and safety alignment. → Multimodal Toolkits (CLIP, BLIP-2, Florence-2, GPT-4o APIs) Text is just one modality. These toolkits let you build agents that understand images, audio, and video, enabling richer input/output capabilities. If you're deep in AI infra or systems, print this out, build a test project around each, and experiment with how they fit together. You’ll learn more in a weekend with these tools than from hours of reading docs. What’s one tool you’d add to this list? 👇 〰️〰️〰️ Follow me (Aishwarya Srinivasan) for more AI infrastructure insights, and subscribe to my newsletter for deeper technical breakdowns: 🔗 https://lnkd.in/dpBNr6Jg

𝐈 𝐡𝐚𝐯𝐞 𝐬𝐩𝐞𝐧𝐭 𝐭𝐡𝐞 𝐥𝐚𝐬𝐭 𝐲𝐞𝐚𝐫 𝐡𝐞𝐥𝐩𝐢𝐧𝐠 𝐄𝐧𝐭𝐞𝐫𝐩𝐫𝐢𝐬𝐞𝐬 𝐦𝐨𝐯𝐞 𝐟𝐫𝐨𝐦 "𝐈𝐌𝐏𝐑𝐄𝐒𝐒𝐈𝐕𝐄 𝐃𝐄𝐌𝐎𝐒" 𝐭𝐨 "𝐑𝐄𝐋𝐈𝐀𝐁𝐋𝐄 𝐀𝐈 𝐀𝐆𝐄𝐍𝐓𝐒".  The pattern is always the same:  Teams nail the LLM integration and think the hard part is done, then realize they have built 20% of what production actually requires. 𝐇𝐞𝐫𝐞 𝐢𝐬 𝐰𝐡𝐲 𝐞𝐚𝐜𝐡 𝐛𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐛𝐥𝐨𝐜𝐤 𝐦𝐚𝐭𝐭𝐞𝐫𝐬: Reasoning Engine (LLM): Just the Beginning • Interprets intent and generates responses • Without surrounding infrastructure, it is just expensive autocomplete • Real engineering starts when you ask: "How does this agent make decisions it can defend?" Context Assembly: Your Competitive Moat • Where RAG, memory stores, and knowledge retrieval converge • Identical LLMs produce vastly different results based purely on context quality • Prompt engineering does not matter if you are feeding the model irrelevant information Planning Layer: What to Do Next • Breaks goals into steps and decides actions before acting • Separates thinking from doing • Poor planning = agents that thrash or make circular progress Guardrails & Policy Engine: Non-Negotiable • Defines what APIs the agent can call, what data it can access • Determines which decisions require human approval • One misconfigured tool call can cascade into serious business impact Memory Store: Enables Continuity • Short-term state + long-term memory across interactions • Without it, every conversation starts from zero • Context window isn't memory it's just scratchpad Validation & Feedback Loop: How Agents Improve • Logging isn't learning • Capture user corrections, edge cases, quality signals • Best teams treat every interaction as potential training data Observability: Makes the Invisible Visible • When your agent fails, can you trace exactly why? • Which context was retrieved? What reasoning path? What was the token cost? • If you can not answer in under 60 seconds, debugging will kill velocity Cost & Performance Controls: POC vs Product • Intelligent model routing, caching, token optimization are not premature they are survival • Monthly bills can drop 70% with zero accuracy loss through smarter routing What most teams miss: They build top-down (UI → LLM → tools)  when they should build bottom-up (infrastructure → observability → guardrails → reasoning). These 11 building blocks are not theoretical. They are what every production agent eventually requires either through intentional design or painful iteration. 𝐖𝐡𝐢𝐜𝐡 𝐛𝐥𝐨𝐜𝐤 𝐚𝐫𝐞 𝐲𝐨𝐮 𝐜𝐮𝐫𝐫𝐞𝐧𝐭𝐥𝐲 𝐮𝐧𝐝𝐞𝐫𝐢𝐧𝐯𝐞𝐬𝐭𝐢𝐧𝐠 𝐢𝐧? ♻️ Repost this to help your network get started ➕ Follow Anurag(Anu) Karuparti for more PS: If you found this valuable, join my weekly newsletter where I document the real-world journey of AI transformation. ✉️ Free subscription: https://lnkd.in/exc4upeq #GenAI #AIAgents

Atlassian's latest research on the developer experience revealed a critical issue: the disconnect between developers and leaders. We surveyed over 2,100 developers and managers, and found significant inefficiencies impacting the developer experience. Only 44% of developers feel their leaders are aware of these issues, highlighting a misalignment that can hinder team success. At Atlassian, we're dedicated to enhancing developer joy—an approach that combines operational metrics with satisfaction to boost retention, engagement, and productivity. Over the past 18 months, we've heavily invested in understanding our developers’ needs by placing them at the center. Through surveys, deep dives, and forums, we were able to uncover real challenges, which has guided our focus on what truly matters. We have taken concrete actions, such as setting OKRs, funding dedicated teams, and encouraging a 10% time allocation to address pain points. We are by no means finished, but we have already seen a 25% increase in developer satisfaction and nearly halved issue cycle times in a year. Improving the developer experience is an ongoing process that requires attention and iteration. We're focused on aligning leadership and developer perspectives to drive meaningful change. By prioritizing developer joy, we're not only enhancing productivity but also fostering a culture where our developers thrive. Check out the report ⬇ https://lnkd.in/gvbsAS9N

Every time a new LLM version is released, thousands of teams go through the same painful prompt migration loop: Run evals > Find regressions > Fix prompts > Re-run evals > Repeat. This is because there no guarantee for behavioral backward compatibility from LLM providers. This is wasteful. Prompt migration should not be solved by every enterprise alone. The model provider knows what changed. The customer knows what behavior matters. The community sees the recurring failure patterns. But today, most of the migration burden sits with the customer. 𝗪𝗵𝗮𝘁 𝗶𝗳 𝘄𝗲 𝘁𝗿𝗲𝗮𝘁𝗲𝗱 𝗽𝗿𝗼𝗺𝗽𝘁 𝗰𝗼𝗺𝗽𝗮𝘁𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗮𝘀 𝗮 𝘀𝗵𝗮𝗿𝗲𝗱 𝗲𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺 𝗽𝗿𝗼𝗯𝗹𝗲𝗺? 𝗟𝗟𝗠 𝗽𝗿𝗼𝘃𝗶𝗱𝗲𝗿𝘀 could publish richer migration notes: behavior changes, tool-use differences, structured-output changes, safety shifts, and known prompt patterns that may regress. The 𝗰𝗼𝗺𝗺𝘂𝗻𝗶𝘁𝘆 could create open migration best practices & benchmarks for common prompt patterns: extraction, classification, tool calling, RAG, summarization, policy checks, and agent workflows. 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲𝘀 could define prompt behavior contracts: what must remain stable, what can change, and what needs human review. This would move prompt migration from a manual repair exercise to a more repeatable compatibility discipline. Prompts are becoming production assets. Model migration needs production-grade support. What are your thoughts on this?

𝐖𝐡𝐚𝐭 𝐚𝐮𝐭𝐨𝐦𝐚𝐭𝐞𝐝 𝐭𝐨𝐨𝐥𝐬 𝐚𝐫𝐞 𝐛𝐞𝐬𝐭 𝐟𝐨𝐫 𝐏𝐑 𝐫𝐞𝐯𝐢𝐞𝐰𝐬? Automated security checks and code quality audits during pull request reviews make the lives of developers easier. Many issues are flagged and caught early on, allowing developers to make quality corrections without the need for a lengthy and often imprecise human review process. During my career, I've noticed that the best-performing teams have always invested in automated quality checks, freeing up time to focus on quality solution design and delivery. 𝗛𝗲𝗿𝗲 𝗮𝗿𝗲 𝘀𝗼𝗺𝗲 𝘁𝗼𝗼𝗹𝘀 𝗳𝗼𝗿 𝘁𝗵𝗲𝘀𝗲 𝗽𝘂𝗿𝗽𝗼𝘀𝗲𝘀 𝘆𝗼𝘂 𝘀𝗵𝗼𝘂𝗹𝗱 𝗸𝗻𝗼𝘄 𝗮𝗯𝗼𝘂𝘁: 𝙎𝙚𝙘𝙪𝙧𝙞𝙩𝙮 𝘾𝙝𝙚𝙘𝙠𝙨 1. SonarQube: Provides comprehensive code analysis to identify bugs, vulnerabilities, and code smells in your code. It supports a variety of programming languages and works with GitHub, GitLab, and Bitbucket for PR analysis. 2. Snyk:  It works seamlessly with GitHub, GitLab, and Bitbucket, offering real-time scanning and remediation advice within PRs. 3. Checkmarx: Provides static application security testing that can identify security vulnerabilities within your code. It supports a wide range of programming languages and integrates with CI/CD pipelines for automated scanning. 4. Fortify: Offers static code analysis tools that help identify security threats and vulnerabilities in the application code early in the development cycle. It supports integration with popular development tools and environments. 5. GitHub Advanced Security: If you're using GitHub, its Advanced Security features include Code Scanning (leveraging CodeQL for semantic code analysis) and Secret Scanning, which are great for catching security issues during PR reviews. 𝘾𝙤𝙙𝙚 𝙌𝙪𝙖𝙡𝙞𝙩𝙮 𝘼𝙪𝙙𝙞𝙩𝙨 1. ESLint/Pylint/Rubocop: Depending on your programming language (JavaScript, Python, Rub), these linters help enforce coding standards and identify problematic patterns in code. They can be integrated into the PR review process to ensure code quality and consistency. 2. CodeClimate: Offers automated code review for maintainability and test coverage, supports multiple languages, and integrates with GitHub for PR reviews. It provides insights into the health of your codebase over time. 3. StyleCop (for .NET): Analyzes C# source code to enforce a set of style and consistency rules. It can be integrated into the build process to ensure that PRs meet the defined coding standards before merging. 4. Coverity: Offers static code analysis to identify software defects and security vulnerabilities in C, C++, Java, and other languages. It can be integrated with CI/CD pipelines for automated code quality checks. 5. Codacy: Automatically identifies issues through static code analysis. It supports a wide range of languages and frameworks and integrates with GitHub, GitLab, and Bitbucket for real-time feedback on PRs. #technology #softwareengineering #programming

We rebuilt 100+ CI/CD pipelines for top SaaS companies. Here’s what we clean up first (and why every pipeline gets instantly healthier when we do): 1. Bloated YAMLs full of conditionals nobody understands. Most CI files evolve like a junk drawer. People keep adding edge cases, temporary fixes, and legacy logic… and no one ever removes them. ✅ What we do: Break down massive YAMLs → move logic into clean, reusable scripts → use templating if needed, but keep it boring. The goal isn’t clever. It’s clarity. 2. Useless test jobs nobody tracks anymore. We’ve seen pipelines running 10+ tests that haven’t failed in years (and nobody can explain what they’re testing.) ✅ What we do: Audit every job → kill flaky or unowned tests → tag what remains with an owner + runtime budget. Rule: If it’s unowned, it’s out. 3. Frankenstein toolchains that slow everything down. The worst setups are part GitHub Actions, part Jenkins, part ArgoCD, and 100% chaos. ✅ What we do: Pick one core system. Reduce touchpoints. Replace brittle glue scripts with shared libraries. Monolith pipelines = faster iterations. 4. Deploys without rollback or visibility. You’d be shocked how many teams push to prod without alerts, health checks, or rollback logic. ✅ What we do: Add progressive rollout → real-time alert hooks → automatic revert on failure. Shipping to prod shouldn't feel like gambling. 5. Over-permissioned runners. Still seeing pipelines with long-lived IAM tokens and full cloud access? ✅ What we do: Move to short-lived tokens via GitHub OIDC or AWS STS. Scope access down to the least privilege required. Security should be baked into the pipeline. Not duct-taped later. CI/CD doesn’t break because the tools are bad. It breaks because nobody takes ownership of the pipeline like they would their app code. What’s your first move when fixing a messy pipeline? ♻️ 𝐑𝐄𝐏𝐎𝐒𝐓 𝐒𝐨 𝐎𝐭𝐡𝐞𝐫𝐬 𝐂𝐚𝐧 𝐋𝐞𝐚𝐫𝐧.