Nowadays, everyone wants to be what we call a "10x developer." However, this term is often misunderstood and overvalued.
In essence, a productive or 10x developer, in my opinion, is someone who can use all the tools available to his advantage, by letting these tools take care of redundant and repetitive tasks and enabling him to focus on complex and creative work. Here are some tips and tricks to become a 10x developer:
Automate Repetitive Tasks with scripts:
Automating repetitive tasks through scripting is a game-changer for developers seeking to optimize their workflow.
By figuring out which tasks can be automated like testing and deployment and then letting scripts handle them, developers can focus on the more challenging parts of their job and save a bunch of time in the process.
For example, this script creates a new project folder, named by user input, and opens it in the file explorer:
import os
import subprocess
def create_project_folder(project_name):
# Create a new folder for the project
os.makedirs(project_name)
# Open the project folder in the file explorer
subprocess.run(['explorer', project_name])
# Get the project name from the user
project_name = input("Enter the name of your new project: ")
# Call the function to create and open the project folder
create_project_folder(project_name)
Keyboard Shortcuts Mastery :
Mastering keyboard shortcuts in your code editor or IDE is crucial for speeding up your coding workflow.
Some shortcuts exemples for VS code:
Ctrl + P: Quick file navigation, allowing you to open files by name.
Ctrl + Shift + L: Select all occurrences of the current word.
Ctrl + /: Toggle line comment
Ctrl + A: Selects all the lines in the current file
Ctrl + F: Finds a specific text in the code
Ctrl + Shift + P: Open the command palette for various commands.
Alt + Up/Down Arrow: Move the current line up or down.
Shift + Right Arrow (→): Select the character to the right of the cursor.
Shift + Left Arrow (←): Select the character to the left of the cursor.
Alt + Click: Hold down the Alt key and click at different locations in the code to create multiple cursors, allowing you to edit or type in those locations simultaneously.
Don't Over-Engineer:
Avoid the temptation to over-engineer your solutions. Adding unnecessary code or architectural complications is a common pitfall that many engineers and programmers encounter.
However, keeping it simple not only benefits your current workflow but also makes it easier for others to understand and collaborate on your code in the future.
Mastering Version Control Workflow:
Becoming good at using Version Control Workflow, like with Git, will tremendously boost your productivity and help your team to work together without stepping on each other's toes.
Especially with tools like GitKraken or any other GUI alternative that provides an intuitive interface that simplifies tasks like branching, merging, and tracking changes, making collaboration smoother.
And if something goes wrong, you can easily go back to how things were before. It's like having a safety net that makes sure everyone's work fits together smoothly, making the whole process of building software much faster and less stressful.
Utilize Existing Components and Libraries:
Instead of reinventing the wheel, use tried-and-tested solutions that are available. This not only saves time but also makes your code more reliable and efficient.
This approach allows you to focus more on the unique aspects of your project. It's a smart strategy to enhance productivity and create robust software without starting from scratch.
Embrace HTML Emmet for Rapid Prototyping :
Emmet is a toolkit for web developers that allows for quick and efficient coding through abbreviations.
If you are using HTML, Emmet can dramatically speed up the process of creating HTML structures.
example:
div>(header>ul>li*2>a)+footer>p
Output:
<div>
<header>
<ul>
<li><a href=""></a></li>
<li><a href=""></a></li>
</ul>
</header>
<footer>
<p></p>
</footer>
</div>
Leverage AI Assistance:
- GitHub Copilot : Is an AI-powered code completion tool developed by GitHub in collaboration with OpenAI. It transforms the way developers write code by generating intelligent suggestions and auto-completions as they type. It's one of the best AI tools I've tried so far.
- TabNine : Is an AI-driven autocompletion extension for code editors. It goes beyond traditional autocompletion by using machine learning models to predict and suggest entire lines or blocks of code. Users can choose to use TabNine for free with some limitations or opt for the Pro version by subscribing to gain access to advanced functionalities.
- Chatgpt : ChatGPT can be a real game-changer for your productivity. For instance, it can provide helpful examples, like suggesting an array for testing or helping reconstruct code snippets.
If you're stuck or need clarification on a programming concept, ChatGPT can offer quick and easy-to-understand explanations. It's like having a knowledgeable coding buddy who's available 24/7 to assist you with coding challenges, making your development process smoother and more efficient.
Extensions in VS code :
Extensions in VS Code can significantly boost productivity by adding functionality, automating tasks, and enhancing the development environment:
- prettier : Prettier is an opinionated code formatter, it automatically formats your code to look clean and consistent, saving you from the hassle of manual formatting. With Prettier, your code becomes easy on the eyes, and you can focus more on writing logic rather than worrying about styling.
- Auto rename tag: The Auto Rename Tag extension is like having a coding assistant for your HTML or XML. When you change the name of an opening tag, this extension automatically updates the closing tag to match.
- Better Comments: The Better Comments extension will help you create more human-friendly comments in your code. With this extension, you will be able to categorise your annotations.
- IntelliSense : IntelliSense is your coding sidekick, offering smart code completion and suggestions as you type. It anticipates your needs and provides relevant options, making coding more efficient.Some examples :
- Peacock : Peacock is super helpful when you're working on lots of projects and jumping around between VSCode windows. It lets you link a color to each project, so whenever you open it, you can quickly see which window you're in by the color.
In conclusion, incorporating these strategies and tools can genuinely revolutionize your approach to coding, transforming you into a more efficient and effective developer. Embracing a 10x mindset not only enhances individual productivity but also positively contributes to your team. So, go ahead, implement these tips, and watch as your coding journey goes to a whole other level.
This article was originally published on my website idboussadel.me.
Top comments (58)
So just use more tools to become a 10x dev? 😀
Don't get me wrong using the best tools for the job is important, but if you want to be 10x effective then the following are crucial as well:
I see a lot of under-engineering in code, over simplification without a view for the future and an understanding of the final goal. YAGNI - you ARE going to need it.... Most good choices are about understanding what is needed in architecture and what is not. 10x is about this for me. A senior attitude not a junior. A focus on the result not the process. Functionality over linting. Users over developers. Execution over elegance.
Very well put.
"My code looks like shit but it works. Leave me alone."
I was suggesting a balance, one that favours functionality over form. If your code looks like shit and is unmaintainable then you've broken multiple of the rules I listed.
A lot of time a "good" developer, that some refer to as 10x, is versatile and dynamic in the setting, tools, contexts and project groups you put him/her in. What separates these people are primarily problem solving skills, understanding of needs, requirements and context and an ability to not just implement but to discuss options and reason the way to the best solution.
A 10x developer could be spending more time in notepad or a whiteboard than anything else just to hash out, illustrate, orient and pivot theoretically with the team and THEN build the right thing one. What you moreover refer to as a "fast developer" in this article is a solo code monkey who will likely be good at building MVPs quickly but his time will ve spend getting it working instead of having a solid plan and goal that is anchored and therefore having a good understanding of what issues all the tools must solve, making it easier and faster to stack it up to a solution. Think first, communicate with tech and non-tech, and versatility is what I look for in new colleagues.
I agree with Bill Eager when he argues in The True 10x Engineer:
BTW in A Tale of Two Kitchens - Hypermodernizing Your Python Code Base I give very similar advice, as you do in this article
I get what you were going for. This is a quality article with some very good suggestions on how to become a better, or a more productive developer, but the title is somewhat clickbaity. :)
The original "10x developer" is largely a myth, and even if it wasn't you definitely shouldn't be striving to be one. If you were able to write 10x more code than anyone else and not lose on quality or your own sanity you wouldn't be working as a regular dev anyway.
Your advice is sound, though, especially using existing tools/components/libraries when you can instead of reinventing the wheel. I would be cautions about using AI in office environment though, as your company might be against that for security/privacy reasons.
I said at the beginning of the article that the term is often misunderstood and overvalued. I am not saying that with my tips you will create 10 more projects than a regular dev but IMHO they will definitely help you write clean code, save you a lot of time, and be more productive.
About AI, yes you're absolutely right some big companies like Google forbid using AI for security reasons.
And for using existing components/libraries you should be careful and use tried, tested secure/maintainable, and scalable solutions.
Thank you for your great comment.
There are also licenses to take into account. I haven't kept up with the latest versions, but AI could generate exact copies of e.g. GPL licensed code which cannot be used in proprietary codebases.
Is it likely to lead to a lawsuit? No. And it is probably very much a gray and unexplored area. But when coding by hand we have to ensure we don't violate licenses and copyright. Just because AI is doing the work we can't throw any considerations out the window.
Few more:
Always degrade junior developers even if they are telling you the right thing tell them that you have 20 years of experience.
Share rules that you don't follow yourself like Propagate that array methods are slow always use old school loops but use array methods all the time.
Call it interpolation instead of template literals.
Lol. I've come to realize people who call template literals interpolation usually come from a CS background. Java to be specific.
Maybe, but I guess they come from University of Flex 😂
This is about typing 10x faster.
That's the wrong goal IMHO
A highly productive developer is often referred to as a "10x dev."
In my opinion, productivity can be boosted through tools like extensions, Emmet, and AI, which facilitate faster typing.
However, mastering Git, automating repetitive tasks, and adhering to the principle of not over-engineering or writing clean code are essential concepts that contribute not only to your typing but also to being a good developer or engineer.
Thank you for your constructive criticism.
I understand and I'm not saying all of this doesn't matter.
But consider the amount of coding it requires to yet another bank with its thousands pages of regulations to implement and that no-body really needs.
Imagine you actually do all this coding 10x better than the average programmer.
Compare that to working on creating "git" in its early stage.
Imagine for example that you would have insisted in making "git" and its syntax more straightforward, the tool easier to learn. Imagine that you would have done this work just at average speed.
I would argue that in the second case you would have worked in something with drastically more impact than in the first case.
The second developer would have been much more efficient than the first who wouldn't have been more productive, but still, it doesn't matter that much in the grand scheme of things.
In the second case you worked on the right things in the right team.
That's when you are really 10x.
Yes, for banks, for example, you can't use external libraries or speed up the process of writing code, or it will be a mess. You have tools, and you should know when to use them.
It’s not just about writing code; it’s about being the engineer who picks the perfect plan for success.
What does success mean though ?
I think that doing the right things is more important than doing things right (or fast).
Nice article here, Abdessamad.
I really like the fact of not over-engineering. Over-engineering often cause more harm than good.
P.S: I'm writing an article on over-engineering, including pitfalls and ways to mitigate it.
I think being a 10x engineer has nothing to do with his ability to churn out more code, but everything to do with enabling whole teams to work more efficiently.
Agreed, it's about delivering 10x more functionality to the user. This is about architecting to succeed and providing an environment where the whole team can flourish. An architect who can deliver a framework where everyone is productive can 10x everyone in the team not just themselves.
People should develop their skills how they want, but there’s no need for us to chase a billionaire’s propaganda or to work more for the same (or less) money.
There’s no such thing as a 10x developer, and we shouldn’t be working so hard to compete with one another for the distinction of having poured 10 times more blood into the gears of capitalism.
Perhaps this is more about the individual, rather than the corporation? I agree that no one should punish themselves for someone else's benefit. It's hard to be recognised though if you choose to be average. It's hard to succeed if you don't take a risk.
I don’t find your argument compelling. Not only do I take issue with the characterization of “choosing” to be average, but this cult of the individual is a pernicious trend.
There’s no such thing as a 10x developer, and anybody competing with others in the pursuit this fiction is only playing into the myths of the billionaires, to the detriment of the community around them.
We can strive to be our best selves without wanting our bosses to compare others to ourselves unfavorably.
Now that you read this, you can call yourself 10X developer.
If it were that easy! 🤣
Being good comes with experience. 🙄
You can’t learn / read it. You have to experience it, over and over again. Expose yourself to the topics you don’t understand yet, get out of your comfort zone and never stop learning.
Just like „get-rich-quick“ schemes, becoming 10X overnight, won’t work.
One thing I don't see mentioned here that's important is making sure the things you work on add as much real value as possible. If you do 100 things nobody cares about and others do 10, still nobody cares. If you do 10 things people actually care about and others do 1 thing of real value then people will notice.
I think this is a good article, but its mostly focused on being more efficient, the tools and practices would make a developer more efficient, so its definitely good advice.
But it might not make you a 10x developer, firstly if 10x is just speed then sure, you can be faster at churning through code, but doesn't mean that you'll create sustainable solutions because this things are not related to any tooling you might use.
So maybe the term 10x dev is a bit misleading, it should just mean a more efficient developer, and by more efficient I mean that its a developer that doesn't lose time on things that can be automated, or uses more of the available tools to create solutions faster.
And for higher levels of developers we already have a name, its Engineer!
I tried copilot and I actually spent more time explaining it what I want than if I did it myself. Even if it wrote something I still have to verify it or tweak it, meaning, that I still had to spend time understanding what was written there. It's like working with a junior developer requiring constant supervision and assistance.
prettifier is an extension that in average makes the code less readable (compared to if you manually try to style it as readable as you possible can yourself) so even if it make the code consistent, do it make the total time reading the code longer. And because reading code is done 100x more than writing, is it bad.
Some comments may only be visible to logged-in visitors. Sign in to view all comments.