Hello, that’s me, Bekir. I’m a full-stack web developer based in Finland, and I’ve been building full-stack applications professionally for the last three years. If you’d like to know more about me, you can always take a look at my About Me page.
For a long time, I’ve wanted to write about what I think and maybe make some videos too, but I could never quite take that first step. So this is it: my very first post. You might read it in passing, you might never read it at all, but for me it’s a big step either way.
In this post, I aim to achieve two primary objectives. First, I will articulate my perspective on programming in the context of rapid advancements in artificial intelligence. Second, I will demonstrate these reflections by sharing the story of my most recent project: building my portfolio website from the ground up. Throughout the essay, I will connect these two themes in order to offer a cohesive exploration of how technological change has influenced both my programming approach and my growth as a developer. In doing so, I seek to provide readers with a clear roadmap of the discussion ahead.
Why Did I Start Programming?
In my stories, the heart of everything lies in the details. Ever since I was a child, I have been fascinated by them. Discovering connections among details and drawing conclusions from them has always given me great pleasure. Expanding my knowledge to fill in the gaps not only made things easier but also opened new paths to solutions.
That’s why, throughout my life, I have tried to cultivate my problem-solving abilities, analytical thinking, and the habit of exploring subjects in greater depth. At one point, I concluded that law or being a lawyer was the profession well-suited to these strengths, so I decided to pursue it. Indeed, those skills proved invaluable in helping me analyze social and legal issues.
However, after graduating, I decided to move abroad to Finland. Once I arrived, I encountered the challenges of trying to continue practicing my profession in a new country. Doing so would have required me to learn a new legal system and adapt to a different environment. Perhaps I could have managed it, but at the time I lacked both the time and the energy. To be honest, although I am quite proficient in Finnish, I realized that I no longer had the desire to apply my skills in that field.
During this period, I found myself searching for something new. Along the way, I became increasingly interested in the world of technology. In fact, technology has been a part of my life since childhood through computers, phones, and other devices. But I’d never really had the chance to ask how these systems actually worked, or to look into them more deeply. Eventually, I said to myself, “Come on, give this a try too,” and set off down this path.
The more I learned, the deeper my curiosity grew. At first, I didn’t really know what I was doing. I was simply learning, solving problems, and turning the solutions I found into instructions a computer could understand. In a way, I had started communicating with computers through software. The excitement and satisfaction that come with learning became something I experienced almost every single day.
Then I realized something: the skills I wanted to use — problem-solving, analytical thinking, and the ability to connect the dots between details — were just as valuable in this field. Once again, I found myself working with details, searching for solutions, planning, and creating. And most importantly, I genuinely enjoyed it.
The only thing left was to find the right direction and bridge the gap in knowledge and experience between myself and others already working in the industry. If you’ve ever tried to teach yourself a new field, you know how difficult that journey can be when there’s no one to guide you. Yet I chose this path because I wanted to spend the rest of my life learning, staying up to date, and embracing the challenge of solving new problems every day.
Software Is More Than Just Writing Code
But enough about my story. I also have a deep appreciation for writing thoughtful and emotional pieces. Perhaps that’s why I wanted to share not only my journey but also how I see things, as both someone who feels deeply and as a developer.
Perhaps people who think the way I do will come across these words and be reminded once again of what a beautiful profession they’re part of. Because one of the greatest things about software development is this: if you have skills beyond software and technology, you’re almost certainly drawing on them when you solve problems. I’m convinced of that.
Even if nothing else, the way you approach a problem is shaped by your skills, your way of thinking, and your emotions. In fact, everything you carry in your mind influences the quality of your work. The human mind is a remarkable thing; what you feed it inevitably shapes what it creates.
That’s why what you think, how you think, and the knowledge you choose to cultivate all matter so much. The relationship you build with knowledge — for better or worse — eventually shapes not only your work, but your life.
Programming in the Age of AI
Having reflected on the broader significance of knowledge and perspective in programming, it is important to consider how recent technological developments are influencing our field. In particular, the rapid advancement of artificial intelligence, and especially large language model (LLM)-based tools, has become increasingly prominent. These tools have become genuinely useful, especially for developers. Problems that once required several people working collaboratively can now often be addressed more efficiently by a single individual with assistance from AI. At the very least, these advancements enable us to take significantly stronger steps toward effective solutions.
Naturally, these developments have also sparked intense debate. Comments such as “developers won’t be needed anymore,” “we’ll all be out of a job,” and especially “things will become much harder for junior developers” are becoming increasingly common. It’s also argued that experienced developers can produce far more powerful work by incorporating these tools into their workflows.
Personally, I think some of these concerns are valid. It has always been difficult for people in technology (engineers and programmers alike) to remain relevant if they fail to adapt to change. But this is nothing new. The need to evolve has always existed, and it always will. Those who follow new developments, integrate them into their workflow, and continue learning along the way will always have an advantage. And I believe that’s where the real point begins.
Depth and Control
I don’t think AI tools will completely take over programming anytime soon. I don’t believe AI has yet reached a point where it can truly compete with the full range of human intelligence, both logical and emotional. It may already excel at logical processes and may even surpass us in many areas. But to create on the same level as a human being, raw computing power alone isn’t enough; emotional depth matters too.
Perhaps one day AI will come even closer to the human mind by creating art, writing literature and books, and building incredibly powerful software. But today, it still relies on human perspective, intuition, and the ability to form emotional connections. After all, the things that truly resonate with people come not only from systems that work correctly, but from creations that carry meaning.
And this is exactly where the qualities that make a developer more productive, capable, and distinctive come into play: depth of knowledge and experience. AI may outperform you in many areas when it comes to solving problems, performing analysis, or noticing details. But depth is something entirely different. Truly understanding how something works beneath the surface, grasping the underlying logic of a system, and applying knowledge and experience accumulated over time to new situations—these remain some of a developer’s greatest strengths.
Without depth, genuine innovation becomes difficult as well. The accumulated knowledge and technical expertise of previous generations made possible many of the technologies and AI tools we use today. So in an era where going deep is valued less and less, what foundation will future generations build upon? From what body of knowledge will the ideas that move humanity forward emerge?
There’s a saying we hear often: “There’s no need to reinvent the wheel.” And in many cases, that’s true. We should absolutely use the tools that make life easier and benefit from the efficiency they provide. But that mindset shouldn’t lead us to treat deep knowledge as unnecessary. Beyond a certain point, we need people who don’t merely use tools but understand their limitations and can discover new paths when necessary.
Reflecting on my own experience navigating new technologies, I observe a similar trend across software development as a whole. The proliferation of modern frameworks, libraries, and templates has made building products significantly more accessible than in the past. As a result, individual developers like myself can now create functional products independently and with greater speed—a change I recognize as genuinely valuable. However, this personal reflection prompts a broader question that extends beyond my journey: Does the increased ease of creation necessarily translate into higher-quality or more meaningful work?
Much of what gets built today is beginning to look increasingly alike. There was a time when a new piece of work had its own spirit, its own identity, something that made it distinctive. Of course, there is still plenty of original and exceptional work being created today, and I don’t intend this as a criticism of everyone. If I’m overstepping, I apologize in advance to anyone who may disagree.
Still, the question remains: why do we see so much similarity? I believe one reason is that many people pursue the tools that make creation easier without developing a deeper understanding of what they are creating. Without depth, the end result often stops being something truly your own and becomes a polished imitation.
Of course, I’m not suggesting that everyone must master every subject down to its deepest level. That wouldn’t be realistic. But I do believe it’s essential to cultivate people with deep knowledge and to give them the experiences that allow them to grow further. This is especially true for developers at the beginning of their careers. Junior developers need to become more than tool users; they need to understand the fundamentals, ask questions, and continue growing through learning.
If we fail to pass down the knowledge accumulated in fields such as software performance, mathematics, physics, hardware, etc., we may eventually become entirely dependent on the tools that make our lives easier. Yet those tools are not infallible. One day, they, too, may reach their limits, make mistakes, or fail to solve new problems. And when that happens, the most valuable resource we will have is what it has always been: people—people with deep knowledge and genuine experience.
Making Mistakes and Creating
So, does the desire to pursue depth sometimes stem from perfectionism? Drawing on my own experience and the experiences of those around me, I’d say yes—it certainly can. It’s easy to become trapped in the pleasure learning provides, endlessly consuming information while postponing the moment to actually build something (a pattern called productive procrastination). Or, confronted by the difficulty and abstraction of what we’re trying to learn, we may become discouraged and give up before we’ve even begun.
But I think there’s something important we shouldn’t forget: depth is rarely gained before taking the first step. More often than not, we discover where we need to go deeper only after we’ve already started moving. The challenges we encounter along the way shape not only our technical abilities but also our character. Perhaps it is these very processes that teach us patience, resilience, and the ability to persevere.
At the same time, simply accumulating knowledge has little value on its own. Knowledge gains meaning when it is acquired with purpose and transformed into something tangible—something we create. Otherwise, even knowledge itself can become a burden. That’s why creating is just as important as learning.
And this principle extends beyond software development. Creation is not merely a professional activity; it is one of the ways human beings realize themselves. To create is to give form to what we know, what we experience, and ultimately, who we are.
So I Built Something With My Own Hands
That belief is exactly what led me to this project. In my last role, I worked closely with AI agents. They accelerated my work, and I won’t pretend otherwise. But somewhere amid all that speed, something began to bother me. Every day, I relied on tools such as pipelines and frameworks, without ever really stopping to understand what they were doing for me. The very things that made my work possible had quietly become black boxes, meaning I could use them effectively but lacked insight into their underlying mechanisms and limitations. As a result, although I was productive, I found these black boxes limiting because they prevented me from deepening my technical expertise and truly understanding the processes at work; in turn, I wasn’t growing in the way I wanted to.
So I decided to start with something small and tangible: a new portfolio website, built entirely by hand, from the very first design decision to the final deployment. I gave myself one rule—no AI-generated code. Every line had to come from me. More importantly, every line had to feel like mine.
For me, the design came first. I wanted to take ownership of the entire UI and UX process—not hand it off, not rely on a template, but genuinely learn how to shape an interface. So I did what I always do when I want to understand something: I went deeper. I watched videos, read articles, and spent time studying two areas I had never given enough attention to before: responsiveness and accessibility.
I chose a minimalist direction, and less is more became my guiding principle. I even spent a surprising amount of time choosing the right typeface because I wanted the typography itself to say something about me—about the care, simplicity, and attention to detail I try to bring to my work.
It wasn’t particularly difficult, but neither was it effortless. Some of the most challenging parts were making the responsive layouts and animations behave exactly as I envisioned, using Tailwind’s utilities and features. Yet every one of those small struggles was worthwhile. In the end, I had something that was entirely my own—not just a website, but a visual expression of who I am.
And yet, I don’t see this project as an endpoint. I see it as a starting point.
Even though I had complete ownership over this website, I still relied on frameworks and tools. The difference this time was that I made a conscious effort to understand what I was using, rather than treating those tools as abstractions. That understanding gave me something I had been missing for a while: a genuine sense of ownership over my code.
This project has also inspired me to go deeper. In the future, I want to explore the technologies I use every day by building simpler versions of them myself. Whether it’s a tool, a library, or part of the development pipeline, I want to understand not only how to use it but also why it works the way it does. I don’t expect to recreate everything, nor do I think that’s necessary. But I believe there is great value in occasionally stepping beneath the layers of abstraction to see what lies beneath.
So this website is only the beginning. I’ll be sharing that journey here in future articles and experiments, documenting what I learn, the mistakes I make, and the things I build along the way. If these ideas resonate with you, I hope you’ll follow along. Perhaps some of those explorations will spark your curiosity as well.
Using AI Without Losing the Joy
At this point, I would like to emphasise the central message of my experience, which is often overshadowed in broader discussions.
Building “by hand” never meant a complete refusal of AI. It meant changing how I used it. Instead of asking it to do the work for me, I started using it in ways that made me sharper rather than lazier:
- Not to generate code, but to test my thinking. Instead of asking it to write something, I’d explain my own approach and ask whether my reasoning held up. It became a thinking partner that pushed back, not a vending machine that handed me answers.
- To discover deeper tools and resources for my specific problem. The right algorithm, a book worth reading, an article that finally explained a concept properly, pointed at exactly what I was stuck on, so I could go and learn it for myself.
- To find real, working examples from the industry, with reference links. When I wanted to see how something is actually done out there, I’d ask for examples I could trace back to the source and understand, not just imitate.
- To get quick feedback, I then ran through my own experience. I’d ask for a second opinion on what I’d built, but I never took it at face value. I validated it against what I already knew. The judgment stayed mine.
The difference is subtle, but it changes everything. Used like this, AI didn’t drain the joy out of programming. If anything, it gave me more of it, because I was still the one doing the thinking, and still the one understanding what was happening under the hood.
A Small Reminder, to Close
I intended this post to serve as a thoughtful reminder to developers and to any readers who have engaged with it thus far. Beyond recounting my personal experiences, my aim is to prompt meaningful reflection on how we approach programming in an era defined by rapid technological advancement. As one of the first articles I have invested significant effort in, it holds special significance for me. I warmly invite you to share your perspectives or insights, should you wish to engage further with these ideas.
I may not be widely known, but I believe that people who live by principles and value careful thought, even if they never accomplish anything extraordinary, live a richer kind of life. I try to be one of those people as well. And I believe that those who choose to live this way always end up changing something, sooner or later.
Perhaps they never built enormous products. Perhaps they are never known by everyone. But they leave an impression. They help someone, inspire someone, or simply make another person think. And sometimes, that’s the most valuable thing of all.