6 skills that can make you a better software engineer

In my eight years in the field, I’ve worked as a software engineer in diverse environments: I was an early employee in a five-person startup and freelanced for about three years before joining Frontify in 2020. I’ve worked with many experts and talents, and I want to share some advice to help up-and-coming software engineers collaborate, engage, and manage.

1. Communicate effectively

Effective written and verbal communication is critical in any field of work that requires collaboration — and software engineering is no exception. We usually work in teams, and straightforward and efficient communication ensures everyone is on the same page and can identify problems early and contribute effectively.

As a software engineer, you’ll write every day: from direct messages to code reviews, commit messages, and documentation. Speaking of commit messages, you may find this git commit message convention useful.

Sometimes you’ll talk to people with a different background, which means that you need to adapt your vocabulary to your audience’s expectations and expertise. Use plain English and be patient when explaining your ideas and processes as simply as possible. Remember that you also have topics you know little or nothing about!

2. Run technical discovery and do a PoC

When you work as a software engineer, some tasks seem repetitive and mundane, while others present unique challenges that you should embrace as an opportunity to grow. One way to tackle these challenges is by taking your time to conduct technical discovery — search for potential solutions, explore technology limitations, and come up with innovative ideas.

To get your hands dirty and learn quickly, you should develop a proof of concept (PoC): a small, functional prototype that demonstrates the feasibility of a new technology or approach. However, it’s important to note that a PoC is not production code — it’s simply a tool used to evaluate the practicability, benefits, and drawbacks of a particular approach.

By conducting technical discovery and by developing PoCs, you can gain a deeper understanding of the problem at hand, identify potential solutions, and make informed decisions on how to proceed. Embracing the challenges and using these tools can ultimately lead to more efficient and effective solutions in your software engineering work.

3. Be open to (early) feedback

Don’t work in a silo: Encourage your team to challenge your ideas and your technical direction. We’re all used to code review, but that’s too far in the game. You’ll save a lot of time if you get a solid concept before writing a single line of production code. All you need is a conversation partner, a napkin, and a pen. The earlier you get feedback, the better.

What’s more: During these early discussions, you can hone other skills such as presenting, collaborating, and critical thinking.

4. Take the time to find meaningful names

How you name variables in your code can make a huge difference regardless of the programming language and the paradigm you’re using. You will thank yourself later, and others will be grateful for saving a lot of time and decreasing friction. Based on my experience, here are a few rules that’ll make everyone’s lives easier:

• Choose names that are truthful and reveal an intention (e.g., attachUrlPropertiesToAsset not process, validateUserInput not checkFields, togglePreferenceSelector not toggle)
• Make sure your names are readable, pronounceable, and searchable (e.g., userPreferences not arr1, key not ky, shipOrder not shpOrdr, index not ___)
• Use one word per concept (e.g., use only one of the following: fetch, retrieve, and get)
• Don’t use abbreviations (e.g., userComments not userComms, database not db, category not cat)

Good naming pays into clean code, and a great read on the topic is “Clean Code: A Handbook of Agile Software Craftsmanship” by Robert C. Martin. I wish I had read it a few years earlier.

5. Aim for high test coverage and experiment with TDD

Testing will enable you to deliver production code with high confidence and help you take a big jump in the quality of the code you write. Test-driven development (TDD) can help you identify and solve issues early in the development cycle, which is much cheaper than identifying and fixing problems in production.

Practicing TDD will get your test coverage close to 100%, which will result in lower maintenance costs in the long run.

6. Have a growth mindset

A growth mindset is a powerful tool that you can leverage in your journey, regardless of the career stage you’re in. The ideas are simple but powerful and may feel like video game cheats for real life:

Face challenges — they’re opportunities to grow and learn. Accept failures as natural parts of the process. Make decisions with confidence: If the outcome is reversible, decide quickly.