​Let’s take a painful trip down memory lane

​The year is 2016. I just graduated. My first fulltime salary? 5,400 ETB. back then, with the rate at 22 ETB/USD, that was a respectable $245

​But wait ... the dollar hasn't been sleeping either. Thanks to US inflation, that $245 in 2016 is worth about $330 today

​If we take that inflation-adjusted $330 and convert it at today’s CBE rate of 154 ETB, do you know what we get?

​💥 50,000 ETB. 💥

​The Conclusion:
To live the exact same lifestyle you had with 5,400 birr in 2016, you need to be earning 50,000 birr in 2026

​Let that sink in

Interviewing is a very important skill to have as a developer. We need to actively practice for improving our interviewing skills as developers. The way to develop interviewing skills is not just solving questions on Leetcode and calling it a day. Interviewers care about how you communicate, what kind of clarifying questions you ask and the way you break down the problem just as much if not more than your coding skills. So mock interviews are the best way to work that interviewing muscle to improve your confidence while also communicating your solution under time pressure.

I use https://www.tryexponent.com/practice for conducting mock interviews with random people around the world every weekend. I noticed that Indians are the most active on the platform and I realized why they are getting much more opportunities in the international job market compared to any other country. I have conducted 9 mock interviews on the platform as of yet and 8 of them were with Indians.

If we want to get great opportunities in the international job market, being able to do the job is not enough. We first need to get our feet in the door. After all, we can't do the job, if we are not offered the job right?😁

Let's focus on skills that get us the job just as much us the skills that allow us to be useful once we get the job.

huge effort → no quick result → frustration → burnout → stop → guilt → restart. 👎

small daily work → small progress → confidence → consistency → results → repeat. 👍

The months since November 2025 have been very amazing for me. It's like getting a big payout from a journey that was long and with very few rewards along the way.

I started programming seriously after I finished Grade 12 just before I joined AAU. In terms of work, I've had some experience with some freelance projects and a few local companies.

In October 2025, I left a job that paid me very little with nothing new to learn and with repetitive tasks.

In November 2025, I got a call from someone I met at a hackathon a year ago and I got offered a part-time job that paid 3x as much as my previous role.

This week, I got my first full-time international remote role for a US company which pays me a salary much higher than my current net worth😅. I hope to learn more from this role and to grow further.

Here are the things that helped me land the role:
1. My communication and interviewing skills which I can attribute to practicing with mock interviews and some tips I got at A2SV regarding optimizing resumes for each role.
2. My projects: I know I haven't shared much here but the projects I did at hackathons, for my own learning... were very crucial.
3. My local experience especially from my last role here. I learnt a lot and improved a lot of my skills in a very short time thanks to the thoughtful code reviews and mentorship from my previous boss.
4. My understanding of low-level, high-level and architectural concepts which I got through my time learning at ALX, books and technical blogs I've been reading

Here are some things I found useful while practicing AI-assisted development.

1. Having a guide file for the agent to refer to like Claude.md, .github/copilot.md, ...: Writing coding standards, commit formats, development workflow rules, links to spec files, docs, plans, and skill files helps very much with getting a predictable output from the agent.

2. Using skills: Anthropic has introduced skills recently and it has been a big improvement for AI-assisted development. I recommend skills related to frontend design, clean code, test-driven development, writing plans, and the framework you use. You can either install open-source skills or create your own for the agent to use and refer to.

3. Using test-driven development: Making the agent write plans and acceptance criteria, writing tests that check for the acceptance criteria, and writing minimal code to pass those tests is a much better way of working with agents in my experience.

4. Clearing the context regularly: Using a new and clear session for every different task will allow the agent to perform better as its context window will not be bloated with too much context.

4. Use MCP servers for Postman, Figma, and Playwright so that the agent can use the tools you use to get direct context for its actions.

Also, plan first, have a conversation with it to refine your plans, review its code carefully, and verify everything by testing it yourself. AI-assisted development is not going anywhere. However, understanding the context, knowing what to build, taking responsibility for the produced code, and defining a workflow that works for us are our roles.

Hope these videos help you with your system design interviews or just deepen your understanding.

If you know better resources, feel free to share them in the comments so others can benefit as well. Learning together always works better.


1. Fundamentals
https://youtube.com/playlist?list=PLCRMIe5FDPsd0gVs500xeOewfySTsmEjf

2. API Design
https://youtube.com/watch?v=DQ57zYedMdQ

3. Load Balancing
https://youtube.com/watch?v=xg7Dj2AXLyk

4. Message Queues
https://youtube.com/watch?v=DYFocSiPOl8

5. Rate Limiting
https://youtube.com/watch?v=MIJFyUPG4Z4

6. Caching
https://youtube.com/watch?v=1NngTUYPdpI&list=PL5q3E8eRUieVFeK1oLahJ8KONkAxDpqk2&index=1

7. Sharding & Partitioning
https://youtube.com/watch?v=wXvljefXyEo

8. Database Replication
https://youtube.com/watch?v=oh8GvLf45t0

9. Consistent Hashing
https://youtube.com/watch?v=vccwdhfqIrI

10. CAP Theorem
https://youtube.com/watch?v=RexrINtVh-M

11. Microservices
https://youtube.com/watch?v=vTjeDWhjuUc

12. Fault Tolerance
https://youtube.com/watch?v=3Lis4w4_bBc

13. Scalability
https://youtube.com/watch?v=tjubQ97lxA4

14. Event-Driven Architecture
https://youtube.com/watch?v=Fb_0UOD2X2I

15. Service Discovery
https://youtube.com/watch?v=v4u7m2Im7ng

Achieving goals in life is much easier with clear direction and clear commitments we follow with dedication. I also believe that documenting our goals and commitments is a very good way of keeping track of our progress and keeping ourselves accountable. I am going to try following the below method in order to keep track of my goals and keep my habits in check.

1. Define clear goals with respective deadlines.
2. Define clear daily and weekly habits under each goal so that I can see clearly what I have to do.
3. Keep track of my daily habits and review my consistency from time to time.

For this, I thought of using pen and paper but thought that might be very hard to keep track of.

Therefore, I built a simple tool that I am going to use to define my goals and habits, look at habits due for today and log them, record my consistency and streak as well as show me which goals I am working more towards.

I built the tool for my own use but you can also visit and use it for yourself if you want to follow the same method of keeping yourself accountable. I used Claude Opus 4.6 and Codex to quickly roll it out.

Here is the link: https://zenith-blush.vercel.app/

There is no denying that AI agents has changed the way we do things as developers.

1. Understanding a New codebase
Before the agents: We would go through the documentation (if it exists it has always been very helpful) and the README and try to follow the instructions to setup the project on our machine. We would then go through the architecture diagram to understand the high level architecture and we would go to the specific parts of the codebase where each component is implemented to try and understand how each part is implemented and also to get a feel of how the coding standards are like for that project. We might even trace the flow of data using pen and paper to better understand a specific part where we are performing our tasks.

Now: Although the above methods are still helpful for us we might use an AI agent to summarize the docs, generate an architecture diagram where it does not exist, explain specific components, trace out and display data flow on a particular part. We can even have a conversation with the AI agent asking it questions and describing our assumptions to better understand the codebase in a conversational style. Of course if the codebase is very large, it takes better planning and context feeding to get the desired outcome from the agent.

2. Debugging
Before the agents: When we receieve a bug report, we try to reproduce it on our machine. If we can't it is even harder to debug since there might be deadlocks or race condition issues that presented themselves in a production environment while being invisible for us. So we might resort to utilizing our observability metrics and using stress testing to figure out the problem. We then try to trace the flow of data through the code using print statements or a debugger and identify where it went wrong. We would then plan and implement a fix based on our understanding of the issue.

Now: We can utilize an AI agent in every step of finding out where the issue lies, figuring out what went wrong and planning and implementing a fix. We do need to control how much we are outsourcing to the AI agent so that we can be sure about the result and we do not lose context of what we are doing.

3. Writing tests & docs
This is by far the best utility of AI agents to save our time on writing verbose tests and detailed documentations. We can actually ask the AI agent to write tests and we can read the test and look for uncovered edge cases which we can iterate with the AI agent to fill out. We can also let the AI agent write docs and we can read, iterate and verify with improved efficiency compared to what we would have done before AI agents.

4. Implementing new features
When we plan a new feature, we can involve an AI agent to poke holes in our plans, remind us of our oversight and even give us new alternatives to explore and decide on. We then can feed the AI agent our finalized plan and let it write the code for us. We then need to review the code and validate everything is according to plan. Which improves our efficiency a lot by focusing our attention on the plan and architecture instead of also typing out every single line of code. This works better if we provide the agent with clear instructions and an unambiguous plan to the best of our abilities.

We still need our judgement and technical skills to produce quality work. We can also utilize AI to accelerate our progress while doing our work.

I built my own JSON parser in Go and it taught me a few things.

1. Lexical analysis: Going through a string and extracting valid pieces aka tokens. I built a JSON lexer that goes through a string and picks up braces, array brackets, strings with validation for escape characters inside them, numbers, boolean and null keywords. This is the first part for any tool that analyses syntax.

2. Syntactic analysis: Going through the valid tokens and validating their correct placing in the overall structure. I built a parser that recursively parses the tokens in their respective order validating they are placed in the correct order.

3. Recursive Descent: I've only really used recursion when I was solving DSA problems before but I saw a real use case for it when I was building a JSON parser. The logic would have been very bloated and hard to follow without recursion.

4. Edge cases: There are many edge cases when parsing JSON so it allowed me to think about some very minor details which can make or break the functionality. I implemented white space ignoring capability for the lexer, validated the escape sequences for validity, made the number identification robust by handling positive and negative integers, exponential and fractional numbers while catching cases where invalid leading zeros exist. I also implemented a max nesting depth in the parser.

Building such projects is a really amazing learning experience where attention to detail and patience is tested. I'm glad for having done it.
Here is the link for the repo: https://github.com/abeni-al7/cuneiform
Project idea credit: https://codingchallenges.fyi/

Software is not just about writing some code that runs to perform some tasks and calling it a day.


Software should be:

- Well tested, so that future functionalities are less likely to break the already working parts.

- Well documented, so that it is easier to extend when new functionalities are needed, easier to debug when problems arise and easier to reason about to maintain it for a long time.

- Cleanly structured, so that it is easier to test, document and improve easily.

I have been using Zenith for a while and I noticed a bug caused by a hard-coded value during development in the analytics. I have since resolved the bug and also added some polishing.

I thought this was only going to be used by me, but I was amazed by the number of people who let me know that they liked it and that they would be using it. I just got a very small number of messages from people who tried it but it still feels good to know that my code is serving others in addition to myself.

Learn AI for free directly from top companies.

1 - Anthropic:
anthropic.skilljar.com

2 - Google:
grow.google/ai

3 - Meta:
ai.meta.com/resources/

4 - NVIDIA:
developer.nvidia.com/cuda

5 - Microsoft:
learn.microsoft.com/en-us/training/

6 - OpenAI:
academy.openai.com

7 - IBM:
skillsbuild.org

8 - AWS:
skillbuilder.aws

9 - DeepLearning.AI:
deeplearning.ai

10 - Hugging Face:
huggingface.co/learn

Using AI for developing Software can indeed speed up delivery if done the right way. I personally like the plan, test, code, refactor loop better when working with AI agents to do this in a safe way. Reviewing the code generated is also a non-negotiable, as code by itself is a liability, and we do not want a lot of code in our codebase for which we have no context for how it works. This is also why I am skeptical of posts where people are claiming to have been generating thousands of lines of code per day.

In contrast, always using AI for coding also wears out our coding skills over time. I fear that this, in turn, might wear out our code reviewing skills as well in the long run. This is why I think we should still be coding by hand from time to time.

Although I myself have been using AI for coding at work for a long time now, I have recently decided to avoid AI while doing projects for my own learning. I think this would help me train my coding muscles and stay sharp in my reviewing skills as well.

I still use AI for writing tests, refining my documentation, and doing small refactors in my personal projects. But I have decided not to write my own projects from scratch with AI.

The one thing I understood that made Software Engineering approachable for me was that everything is a tradeoff.

There is no perfect solution to any problem. No solution comes with only upsides. The solution to a problem also introduces another overhead.

Our job is to balance the pros and cons of our chosen approach so that it fits into the requirements of the business we're solving the problem for.

Its fully Confirmed now That Anthropic is adding Ethiopia to Supported Countries List!!!

Its rolling from Claude code first!