Enhancing Developer Experience

As CTO, I’ve seen firsthand the increasing complexity that our software development teams face. They’re stretched thin—juggling everything from security vulnerabilities to cloud configuration, leaving little time for the creative parts of the job, like writing code. This trend isn’t surprising. The industry’s focus has been on maximizing productivity with less, but productivity, especially for developers, is notoriously difficult to measure. At Atlassian, we’ve taken a different approach. We’ve shifted our focus to what makes our developers happy—or “developer joy” as I like to call it. Not the fleeting happiness from perks, but the deep fulfillment from creating something valuable. We’re betting big that increasing developer joy will naturally improve productivity. That’s why we embarked on this research. In partnership with DX, we surveyed over 2,100 developers and managers to get a fresh understanding of the developer experience. Improving developer experience is a challenge we all share. While this snapshot may not perfectly reflect your team’s situation, it should offer some valuable insights. For Atlassian, this research has revealed new information that my team and I are working to implement. We’re committed to unlocking every team’s potential, starting with our own. May this report inspire you to do the same! https://lnkd.in/gtYzMFks

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

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.

🔊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.

RIP coding? OpenAI has just introduced Codex — a cloud-based AI agent that autonomously writes features, fixes bugs, runs tests, and even documents code. Not just autocomplete, but a true virtual teammate. This marks a shift from AI-assisted to AI-autonomous software engineering. The implications are profound. We’re entering an era where writing code can be done by simply explaining what you want in natural language. Tasks that once required hours of development can now be executed in parallel by an AI agent — securely, efficiently, and with growing precision. So, what does this mean for human skills? The value is shifting fast: → From execution to architecture and design thinking → From code writing to problem framing and solution oversight → From syntax knowledge to strategic understanding of systems, ethics, and user needs As Codex and other agentic AIs evolve, the most critical skills will be, at least for SW tech roles: • AI literacy: knowing what agents can (and cannot) do • Prompt engineering and task orchestration • System design & creative problem solving • Human judgment in code quality, security, and governance It’s a new world for solo founders, tech leads, and enterprise innovation teams alike. We won’t need fewer people. We’ll need people with new skills — ready to lead in an agent-powered era. Let’s embrace the shift. The real opportunity isn’t in writing code faster — it’s in rethinking what we build, how we build, and why. #AI #Codex #FutureOfWork #SoftwareEngineering #AgenticAI #Leadership #AIAgents #TechTrends

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.

CTO: Can we skip code documentation for this sprint? We’re tight on deadlines. Software Developer: Skip documentation? How will the next dev understand what we built? CTO: We’ll figure it out later. Code is self-explanatory, right? Software Developer: Code explains what it does. Documentation explains why it does it. Without context, even clean code becomes a puzzle. CTO: But we need to move fast. Software Developer: Move fast today, stall tomorrow. Good docs are how teams scale and survive turnover. Write for the next developer — even if that's you in six months. Lesson: 🔘 Code is for computers. Documentation is for humans. 🔘 Undocumented systems rot faster than badly written ones. 🔘 Speed without clarity is just deferred confusion.

The Context Engineering Framework is quickly becoming one of the most important tools for anyone building reliable LLM systems. Getting the model to respond is the easy part. The real challenge is: → What should the model know right now? → Where should that info come from? → How should it be structured, stored, retrieved, or compressed? That’s exactly what this framework solves. 🧠 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 Context engineering = designing dynamic systems that deliver the right info, in the right structure, at the right time, so models can reason, retrieve, and respond effectively. This matters most in agents, copilots, retrieval-augmented pipelines, and anything with memory or tools. ⚙️ 𝗜𝗻𝘀𝗶𝗱𝗲 𝘁𝗵𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 Here’s the 3-layer system I use when designing end-to-end LLM workflows 👇 1️⃣ Context Retrieval & Generation → Prompt Engineering & Context Generation → External Knowledge Retrieval → Dynamic Context Assembly 2️⃣ Context Processing → Long Sequence Processing → Self-Refinement & Adaptation → Structured + Relational Information Integration 3️⃣ Context Management → Fundamental Constraints (tokens, latency, structure) → Memory Hierarchies & Storage Architectures → Context Compression & Trimming 🧱 All of this feeds into the Context Engine, which handles: → User Prompts → Retrieved Info → Available Tools → Long-Term Memory This is what gives your system continuity, task awareness, and reasoning depth across steps. ⚙️ Tools I would recommend: → LangGraph for orchestration + memory → Fireworks AI for fast, open-weight inference → LlamaIndex for modular retrieval → Redis & Vector DBs for scoped memory recall → Claude/Mistral for summarization and compression If your system is hallucinating, drifting, or missing the mark, it’s likely a context failure, not a prompt failure. 📌 Save this framework. 📩 Share it with your team before your next agent or RAG deployment. 〰️〰️〰️ Follow me (Aishwarya Srinivasan) for real-world GenAI system breakdowns, and subscribe to my Substack for deep dives and weekly insights: https://lnkd.in/dpBNr6Jg

Scope creep can come from anywhere, and when it hits, it can derail any project and push it to its doom. How to avoid this? We’ve all been there. The scope was “finalized,” everyone agreed on it, and yet suddenly… new bells and whistles sneak in. But where does it come from? Surely we don't want to change the rules of the game in the middle of it? 1) Late stakeholder requests A senior leader suddenly remembers “just one more thing” they promised to a client. The team has no real option but to fit it in, even if it wasn’t in the original plan. 2) Last-second product ideas Somebody on the product side gets a brainwave halfway through execution. It’s often exciting, but it hijacks the team’s focus and kills momentum. 3) Uncovered technical difficulties Reality bites. That “simple” feature suddenly needs a full redesign because the existing architecture can’t support it. 4) Planned dependencies or external tech collapse The API you counted on? Deprecated. The partner you relied on? Pulled out. Suddenly, your scope balloons just to keep things working. 5) A dramatic shift in the market Competitors launch something new or a regulation lands from nowhere, and your project needs to adapt fast. Scope change is fine as an exception. But when it becomes the rule, it’s no longer iteration — it’s feature bloat. How to avoid it? A) Plan the requests as iterations after the MVP release Don’t cram everything in upfront. Launch the core, validate, then add in the extras with intention. B) Put everything in the ROI context. Every new idea should be measured against the cost of delay and potential business return. If it doesn’t move the needle, it waits. C) At least don’t add anything mid-sprint Discipline matters. Mid-sprint additions break flow, demotivate teams, and turn velocity into chaos. D) Remember, you build products to hit goals, not for product excellence’s sake A “perfect” product nobody uses is just wasted time. Always tie scope back to business and user impact. E) Document and communicate scope changes visibly When every change is tracked, it forces accountability. Suddenly, “just one more thing” becomes a conscious trade-off, not a casual ask. Remember: adapting to change is being Agile. Pleasing everyone with no end in sight? That’s toxic, and it will end poorly. Have you ever seen a project’s scope rise beyond any expectations? Let me know in the comments :) #productmanagement #productmanager #agile