Abeni Codes

Is the interview process for other roles really just convo and stuff?

Its fully Confirmed now That Anthropic is adding Ethiopia to Supported Countries List!!! Its rolling from Claude code first!

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.

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.

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

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.

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 built my own JSON parser in Go and it thought 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/

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.

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/

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

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.

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. 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

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.

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

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