AI lowered the entry cost, but the real shift was learning how to own a system instead of just generating code.

Starting From Effectively Zero

Before this project, the closest thing I had to coding experience was editing game save files.

I did not come into this with a computer science background, a software internship, or years of hobby programming behind me. I had used GPT since the GPT-3 era, and I was curious enough to try building with it, but software still felt like something other people knew how to do.

That is the part I want to be honest about. When I say I started from no coding experience, I mean it literally. I was not coming from web dev. I was not coming from scripting. I was not even coming from a serious technical side project. I was coming from curiosity, some comfort experimenting with technology, and the feeling that AI might finally make the gap between idea and execution small enough to cross.

It still felt out of reach. I just tried anyway.

The First Thing That Lit the Fire

The first project that really changed everything for me was the news sentiment analyzer that later became the first version of Pythia Analytics.

At the time, I was working inside a student-managed investment fund, and we had a real pressure problem: too much information, too many companies, and not enough time to read everything deeply from scratch. I built the early sentiment workflow to help narrow the universe faster.

That project did two things for me at once.

First, it gave me a real use case. I was no longer learning in the abstract. I was building something that solved a problem I actually cared about. Second, it proved that this was not just theoretical anymore. Once I got that first version working, it genuinely lit a fire under me.

I have probably put well over 400 hours into coding over the last year, and that momentum started there.

Learning Through One Expanding Project

I did not learn by bouncing between random tutorials. I learned by staying inside one project long enough that it kept demanding more from me.

The progression looked something like this:

  1. build a news sentiment tool
  2. realize it needed valuation
  3. turn it into a mass DCF script
  4. realize that valuation alone still was not enough
  5. keep expanding into analysis, portfolio construction, thesis tracking, macro context, and trading workflows

That mattered because every new feature forced me to learn a different kind of thinking. One week the problem was getting something to render. Another week it was understanding a callback chain. Then it was data flow, persistence, architecture boundaries, or how to make a feature survive contact with the rest of the system.

The repo became the curriculum.

The Hardest Part

The hardest part was not typing code. The hardest part was trying to implement financial concepts I had only recently learned into software at a time when ChatGPT was far less capable than it is now.

Back then, it often felt like the model could only give you twenty lines of code that were consistently good before things started drifting. That meant I could not just ask for a full solution and trust it. I had to break problems down, test constantly, and slowly develop enough understanding to tell when the output was wrong, shallow, or incompatible with the rest of the app.

The workflow itself was also much more frustrating than it is now. The context windows were small. I was working out of browser chats and then pasting into VS Code. I was constantly re-uploading the same files or documents into new conversations just to restore enough context for the next step. A lot of the process was not elegant building. It was fighting the tooling just to keep momentum.

That challenge was brutal, but it was also productive. It forced me to do more than prompt. I had to translate concepts.

I had to ask questions like:

  • What does this valuation idea actually mean in code?
  • What data shape does this financial logic require?
  • What assumptions am I hard-coding without realizing it?
  • Is this result financially coherent, or just syntactically valid?

That is where a lot of the real learning happened.

What AI Actually Changed for Me

AI changed the cost of entry.

It did not make software effortless. It made software reachable.

That difference matters. Before tools like GPT, the gap between "I have an idea" and "I can build a version of it" felt enormous. AI shrank that gap enough that I could stay engaged instead of bouncing off the first wall.

It helped me:

  • ask basic questions without embarrassment
  • move from idea to first draft quickly
  • keep iterating when I got stuck
  • learn unfamiliar concepts in the context of a real build

The most important effect was not that it wrote code for me. The most important effect was that it kept me in motion long enough to build repetition, and repetition is what turns possibility into competence.

What I Believe Now

AI is powerful, and it should not be ignored.

That is one of the biggest conclusions I have taken from this whole process.

I do not think AI eliminates the need for judgment. It does not. It can be wrong, shallow, overconfident, and structurally careless. But I do think it has fundamentally changed who gets to participate in technical work.

My view now is simple: everyone can become competent in something with these tools if they are willing to stay with the frustration long enough.

That does not mean mastery is free. It means the door is open in a way it was not before.

What makes me believe this even more strongly is when much of this project was built. A large portion of Pythia Analytics was built with much weaker, more novice-stage LLMs, before the current wave of IDE integration made the workflow dramatically smoother. If these earlier tools were powerful enough to help me cross from zero experience into building a system like this, then the implication now is even stronger: these tools are not optional background noise. They are a real shift in how people can learn and create.

That is also why I think coding is one of the best ways to learn how to use AI well. Coding forces precision. It exposes shallow thinking immediately. It teaches you how to break work into pieces, test outputs, debug mistakes, and distinguish between something that sounds plausible and something that actually works.

The Shift Into Feeling Like a Builder

I know there was a point where this stopped feeling like "I am trying to get AI to help me code" and started feeling more like "I am actually building systems now."

I just cannot tell you the exact day it happened.

It was gradual.

It happened through repetition:

  • writing something rough
  • debugging it
  • realizing the structure was weak
  • rewriting it
  • watching the next version hold together a little better

That is probably the most honest description of the transition. Confidence did not arrive all at once. It accumulated.

At some point, software stopped feeling like a sealed-off discipline and started feeling like a medium I could think in.

Why This Project Matters To Me

Pythia Analytics is not just the biggest project I have built. It is the clearest record of how I learned to build at all.

What began as a narrow sentiment tool turned into a cumulative application with:

  • a deep analysis engine
  • saved research workflows
  • portfolio construction and thesis management
  • macro context
  • a trading and backtesting layer
  • now even a public-facing editorial surface

That matters to me because it shows what happens when AI is paired with persistence. This was not one flashy weekend demo. It was sustained effort, failure, revision, and accumulation.

The project is proof that the line between "non-technical" and "technical" is more permeable than a lot of people think.

It is also, very simply, something substantial that I built. That matters to me. The app is the argument.

Why I Am Sharing This Publicly

I am sharing this because I think the story matters almost as much as the product.

If someone sees the app, I want them to understand two things at the same time:

  1. the software is real
  2. the path into building it was not traditional

That combination is the point.

I also want people I know to see, concretely, how powerful these tools already are. A big part of this app was built with early, much less capable LLMs, before the current tooling made the workflow easier. With today's tools, the case is even stronger. AI is not something serious builders, students, analysts, or curious people can afford to ignore.

And when I say people I know, I mean that broadly: friends, classmates, finance people, older professionals, skeptical people around me, and anyone else who still thinks these tools are mostly hype or mostly for programmers. I want them to see an actual, tangible result rather than just hear abstract claims about what AI might do someday.

I want this to be legible to people who are already technical, but I also want it to say something to people who still think software is beyond them. My experience suggests that with enough persistence, enough curiosity, and the right use of AI, the gap can close faster than most people think. And one of the fastest ways to build real intuition for AI is to try to build software with it, because software gives you immediate feedback on whether your thinking is actually sound.

That is the most important thing this project has taught me.