3 ways I get my engineers to optimise their dev environment for max productivity
Your team’s productivity is worth investing in.
We often fall into the trap of letting productivity take a backseat to immediate delivery pressures, like looming deadlines or pressing feature requests.
It's easy to overlook that the productivity of an engineer, or indeed an entire team, is not a static metric but a variable we can influence.
The irony of productivity is that the more we strive to measure and control it, the more elusive it seems to become. It's essential, then, to shift our perspective.
True productivity emerges not as a goal to pursue relentlessly, but as a natural by-product of a balanced, integrated, and knowledgeable team. Its real measure lies in consistently delivering high-quality results, minimising waste, and maximising joy.
I want to cover three themes that blend technical knowledge with creating the best dev environment for that knowledge to become practice.
Get your team to own their IDE
Your team almost certainly uses a powerful, productive Integrated Development Environment (IDE). But are they getting the most out of it?
Most engineering teams have widely differing levels of knowledge around IDE customisation. Don’t assume every engineer is a whizz. Many treat their IDE like colourful code editors.
This isn’t a blog post about optimising your IDE.
To give you an idea, IDE productivity features you might want your team adopting include:
- Fine-tuned local history. Cmd+Z doesn’t always cut it – adjust the default retention period to give you longer runway to recover lost code.
- Automate repetitive tasks with macros. Many IDEs support recording and executing macros to avoid routines of keystrokes or code alterations.
- Snippet libraries. These are templates that make it easier to enter repeating code patterns, like loops or React functional components, with a single command or keystroke.
Instead, I will cover how to get teams to adopt impactful IDE features.
- Organise IDE features sharing sessions. This could be in a show-and-tell format, where your IDE-confident engineers share their must-know or favourite features. An informal, interactive session will be more impactful than a formal tutorial. The goal isn’t to dictate how everyone should use their IDE, but to make them aware of the possibilities so they can figure out what they like. Record the session for new starters.
- Set up team-wide settings and extensions. Share a baseline IDE settings file covering the customisations everyone will benefit from. For VS Code, this could be a settings.json file. Curate a list of beneficial extensions.
- Develop your sharing culture. However you do this, developing a culture of sharing requires active input. It could involve a Slack channel, or organising a periodic “hack and tell”.
Empower them with DevOps know-how
Your team is probably full of hotshot coders. But how many of them know their way around a Kubernetes cluster? Or can write a clean, reusable Terraform module? Or truly understand the full power of your CI/CD pipelines?
For most developers, these skills are left to the DevOps folks or the "build and release" team. It's time to change this narrative. Why? Because empowering your engineers with DevOps knowledge can supercharge their development productivity.
Skill 1: Container orchestration. Container orchestration is much more than just getting an app to run in a Docker container. Kubernetes, when fully understood and effectively used, can provide a major boost to productivity. No more time wasted on resource allocation or managing application deployment - Kubernetes has it covered. Your team can focus on writing code that adds value to your product.
Skill 2: Infrastructure as code (IaC). Development tools like Terraform and Ansible are not just for your DevOps team. Encouraging your engineers to write reusable infrastructure code and streamline the deployment process will reduce errors and free up your team's time, allowing them to focus on building great features.
Skill 3: CI/CD. CI/CD pipelines are not just a set of automated steps that take code from commit to deployment. By fully leveraging features like shared libraries in Jenkins or build stages in Circle CI, developers can significantly reduce their time spent on maintaining and writing pipeline code. This is time they can spend on, you guessed it, writing more feature code.
So how do you get developers to adopt these practices?
- Begin by prioritising learning. Prioritising, not just encouraging. Learning tools and technologies can often take a backseat in the daily hustle of pushing out new features. Set aside dedicated time for upskilling and protect it fiercely against the onslaught of urgent tasks. And lead by example – you’re also invested in your own growth.
- Facilitate practice. Provide your developers with a safe space - like sandbox environments - where they can experiment and get comfortable with these new tools without fearing breaking anything. Watch their confidence (and productivity) soar.
- Incentivise sharing. For example, introduce "DevOps tip of the month” or follow my earlier IDE suggestions.
DevOps skills – even in a cross-functional team – help engineers tackle code blocks themselves and keep their momentum going.
Open up the lines of Collaboration and Communication
With the right tools and techniques at your team's disposal, productivity gains can be tremendous. But this means little in organisations where things frequently happen in silos.
Open collaboration and transparent communication are paramount for high-performing teams, not least because they help reduce friction and avoid productivity pitfalls.
Now, your engineers are probably comfortable with their favourite collaboration tools. It's essential to ensure these tools are well integrated and play together smoothly. Frictionless data flow between tools can save your team the trouble of duplicate updates, loss of crucial information, or incessant context-switching.
Establishing good practices within these tools can also enhance productivity. For example, well-defined acceptance criteria on Jira tickets can avoid countless back-and-forths. It ensures developers understand exactly what's expected and can get on with the task at hand. Similarly, encouraging transparent communication on public channels rather than one-on-one DMs can save repeated explanations, keep everyone in the loop, and foster an environment of shared knowledge.
- Automate, and have better meetings. Whether through scripts, bots, or other tools, it is worth short-term pain to enjoy months and years of radically reduced admin, such as generating meeting reports. That should mean you can use meetings more productively than just sharing information, and have fewer of them.
- Make use of generative LLMs. There are already numerous generative artificial intelligence solutions for engineering teams that can write your docs, manage your technical debt, auto-approve pull requests and code reviews and more. Here’s a great list of AI tools for engineering teams.
- And go beyond LLMs. More powerful artificial intelligence solutions that can sift through your data, identify trends, and surface what matters most to your team.
I’m building Stepsize AI with my team at Stepsize.
I’d love for you to check it out.
Stepsize AI generates context-aware daily team syncs, weekly or sprintly stakeholder updates for other teams or leaders, and even executive summaries.
It ingests and reflects on data from all the tools you use – including Slack, Jira and GitHub – in a security-conscious way.
And you can tailor updates for any team, for any project.
As we've discovered, fostering productivity in software engineering isn't just about optimising the tools we use or honing our technical skills.
Productivity thrives in a climate where learning and knowledge-sharing are the norms, where DevOps isn't confined to a specific team but embedded in every developer's DNA. It flourishes when collaboration and communication aren't afterthoughts but integral elements of our workflow. It comes alive when we embrace the potential of AI not just as a tool, but as a team member that enhances our capabilities.
Yet, at the heart of this pursuit of productivity lies a paradox. The more we strive to measure and control productivity, the more elusive it becomes. It's time to rethink productivity not as a target to be achieved, but as an organic result of a well-balanced, well-integrated, and well-informed team.
On this principle, we're building Stepsize AI, the AI companion for your software projects.
Stepsize AI isn't just an AI tool; it's a context-aware team member that offers insights, generates reports, and sends alerts when they matter most. It interacts with all your tools – from Slack and Jira to GitHub – providing you with tailored updates for any team, any situation.
From generating an ad-hoc bug report to scheduling a recurring weekly digest, it’s like having an extra team member who’s always aware, always ready, and always knows what matters. We believe it’s a game-changer.