During my senior studies, I would hear stories about programming from my brother and it ignited a dream in me — I wanted to become a programmer. I had no idea what it truly entailed but the dream was alive and burning.
After secondary school I pursued a Bachelor in Software Engineering. In my first year I was introduced to C++ and within that same year I independently explored Python and discovered basic hacking skills. That combination made me happier than anything else I had experienced academically.
Then life took a sudden and unexpected turn, one I never saw coming. I joined the priesthood and entered a major seminary to study philosophy. Suddenly I found myself standing at a crossroads, wondering how to balance the virtues and values of seminary life with my passion for philosophy, Python and the hacking world I had grown to love so deeply. It was a tension I didn't know how to resolve. But what I discovered along the way surprised me completely. It was then that I discovered something that changed everything. Python and philosophy were not as distant as I had imagined. The critical thinking I was developing in the seminary, the ability to question, analyze and reason deeply, had a direct connection to the logical world of coding. Even more exciting was the realization that I could write about AI ethics and technology, combining both worlds into something meaningful and purposeful.
The lost ship had finally found its direction again. The fire that had dimmed was burning once more. But a new question now emerged, how exactly do you connect coding with critical thinking? How do these two worlds practically come together?
That is exactly what this article is about.

When I first tried to merge critical thinking with coding I discovered something fascinating, coding demands the same patience that philosophy requires. When an error appears in your code the worst thing you can do is panic. Instead you sit back, relax and trace your steps carefully, asking yourself where exactly things went wrong. It feels remarkably similar to revisiting a failed philosophical argument from the very beginning.
Just as a failed argument can keep a philosophy student awake at night, a broken piece of code produces that same restless frustration. But the lesson from both worlds is identical, don't panic. Go back calmly and find where the logic broke down. And here is perhaps the deepest connection of all. In philosophy there is a correct syntax for sound and valid thinking, a structure that arguments must follow to reach true conclusions. Code is no different. A program needs correct syntax to run properly and produce the right output. Break the structure and everything falls apart. Follow it carefully and everything works beautifully.
Philosophy had been teaching me to code all along, I just didn't know it yet. Patience With Complexity
I remember vividly the first time I encountered Thomas Aquinas' De Ente et Essentia, a dense and complex philosophical text that left me completely lost for days. My lecturer once told me that once I truly understood that book I would be a real philosopher, because it contained every concept and vocabulary that philosophy demands. That single statement changed my relationship with difficulty forever.
I refused to give up. A phrase kept me going during those long confusing nights; "if it were easy everyone would do it." That simple truth became my anchor whenever things got hard.
That patience was tested again in an unexpected way. My superior once approached me with a request, he needed an attendance application for his class. He told me he didn't care how I did it, I could use AI however I wanted, he just needed a working android app. There was one small problem; I had never built an android application in my life. What followed were sleepless nights of reading, confusion, frustration and relentless trying. I leaned on AI tools, stumbled through errors and pushed through every moment of self doubt. And then finally it worked. The app was built and it worked.
The feeling was indescribable. That moment taught me that complexity is not a wall, it's a door. And patience is the key that opens it. Asking The Right Questions
During my study of epistemology I encountered one of philosophy's most fundamental questions, what does it mean to truly know something? Epistemology taught me that genuine knowledge requires three things: belief, justification and truth. You cannot simply accept something at face value. You must dig deeper, question your assumptions and trace your reasoning carefully before arriving at any conclusion.
One of the most memorable lessons came through a classic philosophical debate whether, is truth subjective or objective? What epistemology taught me was profound and surprisingly practical. We don't always have to choose one side. Sometimes the real wisdom lies in finding a way to make both work together.
That lesson transformed how I approach coding completely. Most beginners are satisfied when their code simply works. They run it, it produces the right output and they move on. But epistemology taught me that working and understanding are two completely different things. Just as a philosopher cannot claim to know something without proper justification, a programmer should never be satisfied with code they don't fully understand.
Understanding why your code works gives you the power to fix it when it breaks. It reveals the logic beneath the surface. And perhaps most importantly it improves the security of your code. When you understand every line deeply you can identify weaknesses, anticipate errors and build something truly reliable.
Philosophy didn't just teach me to think. It taught me to understand and that changes everything in coding. Clear Communication
One of the most demanding lessons philosophy teaches is the art of clarity. In philosophy every word matters. You must use the right words, in the proper way, meaning exactly what you say and nothing more. Vague language is the enemy of good philosophy.
In philosophical argumentation we learn about the defeasibility factor, the idea that a strong argument must be constructed in such a way that it cannot be easily defeated or undermined. Every claim must be precise, every term carefully defined and every conclusion logically supported. A single unclear word can collapse an entire argument.
Coding demands exactly the same clarity.
When you write code that others will read, use or build upon clarity is not optional. Poor documentation confuses users, creates errors and makes maintenance a nightmare. But when your documentation is clear, precise and carefully written it reaches the user effectively and makes your work genuinely useful. Philosophy taught me that clarity is not just about being understood. It is about being understood correctly. And in both philosophy and coding that distinction makes all the difference. Conclusion
My journey has taught me that persistence and commitment are the true foundations of achieving any dream. The road from a seminary student wondering how to balance philosophy and Python to someone who can actually write about their connection has not been easy. But every confused moment, every sleepless night and every small breakthrough has been worth it.
To every beginner out there who feels like they don't belong in the tech world, whether you studied arts, philosophy, theology or anything else, I want you to hear this clearly. Coding is not as foreign as you think. It relates directly to our daily experiences of life. The patience you use to solve a difficult relationship. The logic you apply when making a tough decision. The clarity you need when expressing an important idea. All of that is coding. All of that is programming.
You don't need a traditional tech background to begin. You just need the courage to start and the persistence to keep going.
If a philosophy student in a seminary can do it, so can you.