Level Up Fast: 20 Tips to Supercharge Your Dev Career
The New Developers Playbook
Introduction
Starting your career in software can feel overwhelming. There's code to learn, systems to understand, managers to impress. And now, with AI reshaping the industry at breakneck speed, the pace feels faster than ever. New frameworks, tools, and expectations seem to appear every week.
In a climate this volatile, the safest bet is not trying to predict the future or chase every shiny new technology. The real edge comes from first principles: focusing on habits and mindsets that compound no matter how the landscape shifts.
I can’t make predictions about where the field will be in five years. But I can tell you things that will always have a positive impact. These are habits I implemented myself, and wish I had started earlier.
Below are 20 practical tips, grouped into key themes. Think of them as a playbook for staying adaptable, shipping value, and making yourself indispensable in any environment.
1. Build a Strong Learning Engine
1) Begin with the outcome
Don't just "work hard", define what success looks like six months from now. For example:
"I can own and deploy a small service end-to-end."
"I consistently ship features every sprint."
"I'm confident in system design interviews."
Once you have a clear picture, work backwards. If owning a service is the goal, the habits might be: reading its design docs weekly, shadowing on-call rotations, and practicing deployments.
Bonus: Define what success looks like for your manager. This will help you understand their expectations and how to align your work with their goals.
2) Schedule learning like a feature
If it's not on your calendar, it won't happen. Block out time just like you would a meeting. For example:
Tuesday evenings: 90 minutes reading Designing Data-Intensive Applications.
Thursday evenings: rebuild a small project with tests.
This way, learning compounds just like interest and you won't get stuck only knowing what today's ticket requires.
3) Read to lap the field
Most developers learn reactively, picking up only what's needed for their current project. The problem? When they switch teams or companies, they're back at square one. If you read deeply and consistently, you'll build range that transfers everywhere.
Start with fundamentals: clean code, distributed systems, debugging, testing. Two hours of reading a week separates you from 90% of peers within a year.
[!TIP] 📚 Books that shaped my career:
- Clean Code & Clean Architecture – Robert C. Martin Clear standards for writing maintainable, scalable software.
- The Pragmatic Programmer – Andrew Hunt Timeless principles for thinking like a craftsman.
- The Lean Startup – Eric Ries Showed me the value of small experiments and MVPs.
- Made to Stick – Chip & Dan Heath Taught me how to communicate ideas that stick.
- Algorithms to Live By – Brian Christian Real-world lessons on how algorithms guide decisions.
- System Design Interview – Alex Xu Gave me a clear formula for tackling system design problems.
- Designing Data-Intensive Applications – Martin Kleppmann Deep dive into modern system design fundamentals.
4) Take smart notes
Reading without notes is like trying to fill a leaky bucket. After each chapter or article, capture:
The problem it solves
The key pattern
One thing you'll apply this week
Even one page of notes per chapter creates a reference library you'll actually revisit.
5) Learn How to Learn (and Put in the Hours)
Most of us stop thinking about how we learn after high school, but there’s a lot more we can do to boost our memory and understanding. By improving your learning techniques, you can absorb information faster, retain what matters, and recall it when you need it.
Here are some proven strategies:
- Retrieval practice: Regularly recall and explain concepts from memory.
- Spaced repetition: Review your notes after 1 day, 1 week, and 1 month to reinforce learning. I love using Anki for this.
- Interleaving: Mix different activities like coding, reading, and design thinking throughout your week.
These methods are far more effective than simply re-reading material.
But above all, what matters most is putting in the hours. Don’t stress too much about what to learn next or which framework is “best.” Progress compounds through consistent time investment. Remember the 10,000 hours rule, mastery is built on accumulated practice, not shortcuts.
[!TIP] Recommended books on mastering the art of learning:
- Make It Stick – Peter C. Brown
- Ultralearning – Scott Young
- Limitless – Jim Kwik
- The Art of Learning – Josh Waitzkin
- The First 20 Hours – Josh Kaufman
2. Master Your Tools and Workflow
6) Use AI as a Multiplier, Not a Crutch
A key paradox today is that engineers who thrive are those who can leverage AI to dramatically boost their productivity...sometimes by 10x or even 100x. However, to do this effectively, you need to be able to distinguish between good and bad AI-generated responses.
If you haven’t done the work yourself before, it’s difficult to verify whether the AI’s output is correct. AI can significantly increase your productivity, but only if you know how to critically assess its results.
The best way to build this skill is through practice. Set aside time each week outside of work to experiment with prompt engineering and compare AI outputs to reference code.
7) Keep a prompt & agent library
Save prompts that worked well, tag them by task ("unit tests," "summarize design doc") or by role (backend, frontend, devops, etc). Make sure to store them in a way that is easy to search and use. This way, you're not reinventing the wheel every week.
Even better if you can store them someplace where other memebers on the team can find, use and improve upon them (High impact low effort!)
[!TIP] From Prompts to Agents Coding-focused tools like Claude Code let you turn prompts into specialized sub-agents inside your workflow. The open-source agents.md format standardizes how these agents are defined, and is now supported by tools like GitHub Copilot, Claude Code, and Cursor.
With this setup, agents can collaborate in more complex workflows, for example, pairing a backend agent with a frontend agent to work together seamlessly. This advanced approach can unlock huge gains in productivity and creativity.
8) Grade AI output with a rubric
Don't just eyeball responses. Create a quick checklist: correctness, complexity, tests, readability, security. Run any important AI output against it. This forces rigor and keeps you in control.
9) Do some no-AI reps
Even if AI is everywhere, you'll still do well to equip yourself with being able to code without AI. Here are a few examples of where that might come in handy:
- No internet access
- Interview coding challenges
- Finding bugs in systems
- Collaborating with others to solve problems in situations where you don't have a laptop/computer present
- Requirements in a language the AI doesn't support
- Legal concerns around using AI on certain projects
Keep up personal coding sessions, and periodic days where you work on features without any AI assistance.
Coding without AI helps build taste and intuition. The more you train your problem-solving muscles, the stronger they become.
3. Ship Value Quickly
10) Ship small PRs
The smaller your PR, the faster it gets reviewed, merged, and delivered. Aim for under 200 lines of change. If a task feels huge, slice it: schema migration first, then feature flag, then endpoint, then tests.
11) Plan the PR before you type
Reviewers love clarity. Add a mini-plan in your PR description: the goal, your approach, trade-offs, test plan, rollback strategy. Pre-commit hooks and linters can catch small issues before they reach your reviewers.
12) Code every day at work
Touch the codebase daily. If you can't ship, review someone else's code. If you can't review, read a service's codebase and take notes on style and patterns. Momentum builds skill.
13) Log your progress daily
Interruptions are constant. A daily log ("done, learned, blocked") keeps your memory sharp and doubles as a performance review record. Tools like Obsidian, Notion, or even a simple markdown file work well.
4. Grow Through People
14) Set expectations and ask for feedback
One of the most impactful things you can do to improve your work performance is to align with your manager's expectations.
During your first few weeks, ask your manager this crucial question: "What does 'meets expectations' and 'exceeds expectations' look like in this role?"
Schedule brief weekly check-ins to discuss your achievements, challenges, and upcoming priorities. Maintain a document tracking your accomplishments, including links to pull requests and relevant metrics that tie back to your initial expectations discussion.
I wish I had done this earlier in my career - it's been one of the best professional practices I've adopted. These conversations not only improve transparency and help you stay focused on your goals, but they also make performance reviews and career advancement much smoother. Come review season, you'll have everything documented and ready to go.
But don’t stop at your manager. Make a habit of asking peers for feedback too. This can be game-changing. Schedule regular 1:1s with teammates, and ask about your performance on tasks they’ve seen you do, whether it’s a PR, a presentation, or a collaboration. You’ll learn things managers often miss.
15) Benchmark against peers
No one likes to admit it, but relative performance matters for pay and promotion.
A great way to make sure you're keeping inline with expectations is also by making sure you're keeping inline with your peers. Track signals: PRs merged, reviews given, incidents resolved, docs contributed. etc.
Watch the top performers: ask your manager who they are, ask what systems they use, and copy those systems!
16) Network early, be friendly, and build trust
Begin by connecting with your peers and nearby teams. After about a month, reach out to more senior colleagues with a clear purpose, such as asking, "What does success look like in your team?" or "What's one thing you wish you had known earlier?" Keep a simple contact list to track your connections.
There will be times when you're assigned a task and having someone in your network with relevant experience can make a huge difference. For example, if you're asked to migrate your team's services from on-premises to cloud providers, and you know a lead engineer on the platform team who recently completed a similar migration, you can set up a quick meeting with them. By sharing your plans, they might introduce you to others who can help, offer their own advice, and warn you about potential pitfalls. This single conversation could cut your project time in half.
And remember: being friendly and likeable multiplies opportunities. Once you have a foundation of friendship with someone, it’s much easier to ask questions, get feedback, and collaborate openly. Small things matter! Ask about their personal life, share a bit of yours, grab coffee together, or even play a quick game at lunch. Being a pleasure to work with goes a long way.
[!TIP] There are certain situations where teammates might not feel comfortable sharing about their personal life. Respect boundaries and don’t push. The goal is to be friendly, not intrusive.
17) Learn from experts
Follows on from the previous tip.
A 20-minute chat with the right expert can save you a day of stuck debugging. Before the meeting, send context and your question. After, write a thank-you with what you changed.
18) Present your work
Visibility is half the battle. Demo something small every few weeks. Frame it simply: the problem, constraints, your solution, and what's next. Record it and share with the team. Public thinking sharpens private thinking.
5. Stay Curious and Proactive
19) Create a "where to look" checklist
When you're stuck, don't flail. Follow a set path: internal docs, service runbooks, Slack channels, past tickets, teammates, then formal support. Share your search path when asking for help, it shows diligence.
20) Make your lead's life easier, then bring ideas
The fastest way to earn trust is to remove load from your team lead. Volunteer for coordination tasks, surface risks early, close loops. Once you've settled in, start pitching small experiments: "What if we reduced build time by 15%?" or "What if we automated X?" Managers love juniors who think like owners.
Final Thoughts
Your early career is about momentum. You don't need to be the smartest in the room, you just need to learn faster, deliver value steadily, and build strong relationships. Stack small wins, keep a rhythm, and you'll outpace most peers in just a year or two.
At the end of the day, what matters most is putting in the hours. Don’t obsess over the “perfect” thing to learn. Consistency and compounding practice will carry you further than chasing trends.
