From Browser Tab to Terminal: How AI Became My Co-Builder

I studied mechanical engineering, worked in supply chain at a multinational, then became a product manager. I have never written production code in my life.

Last month, I built an Android app that reads my bank SMS messages, auto-parses every transaction, and visualizes my spending in a dashboard. I also analyzed 660,000 AI chatbot sessions, building a multi-layered behavioral taxonomy with streaming data pipelines and automated classifiers.

All from my terminal. No IDE. No Stack Overflow tabs. Just me and an AI tool running in my command line.

This post is about how I got here. Not overnight, but through three distinct phases of AI adoption that fundamentally changed what I can accomplish as a non-software engineer.

Phase 1: The Question Box (Late 2022 - 2024)

I was one of the early ChatGPT users when it launched in November 2022. Back then, it could not browse the internet, could not search for anything, and had no knowledge of events after its training cutoff. It was a conversational assistant drawing from static training data.

But even in that limited form, it was immediately useful for product work:

• Drafting emails and stakeholder communications
• Brainstorming feature ideas and exploring edge cases
• Learning how large language models actually worked under the hood
• Creating first drafts of PRDs and strategy documents

The workflow was simple: think of a question, switch to the ChatGPT tab, type it in, read the response, copy what was useful, paste it into whatever document I was working on. Repeat.

What this phase taught me: Using AI daily as a consumer gave me an intuition for what large language models can and cannot do. I learned where they hallucinate, where they excel, what kind of prompts produce useful output, and what kind produce garbage.

That understanding turned out to be the most valuable thing I gained from Phase 1. Not the emails it drafted or the ideas it generated, but the mental model of how these systems work.

Why? Because I was about to build one.

When I started leading the development of a curriculum-aligned AI chatbot for millions of students, every design decision was informed by hundreds of hours as a daily AI user. I knew firsthand that generic LLMs would give confidently wrong answers about our national curriculum. I knew that students would try to push the model outside its boundaries. I knew that the difference between a useful AI response and a useless one often came down to how the system was prompted, not which model was used. Being a power user made me a better AI product builder.

Phase 2: The Thinking Partner (2024 - Early 2025)

Sometime in 2024, I started using Claude. The shift was not dramatic at first. It was still a browser tab. Still the same copy-paste workflow.

But the quality of reasoning was noticeably different. Claude could hold longer conversations without losing the thread. It could work through complex strategy problems step by step. It was better at analysis frameworks and at pushing back when my thinking had gaps.

I started using it for:

• Breaking down complex product strategy problems
• Building analysis frameworks for user behavior data
• Working through prioritization decisions with structured reasoning
• Longer, multi-turn conversations that built on previous context

The limitation I hit: The output improved, but the workflow stayed exactly the same. I was still switching between my terminal, my editor, my data tools, and this browser tab. Context was constantly lost. Every new conversation started from zero. And I still could not get AI to actually do anything with my files or data. I could only describe them in text and hope the response was applicable.

This was the copy-paste ceiling. And I did not realize how much it was holding me back until I broke through it.

Phase 3: The Co-Builder (Mid 2025 - Present)

The shift happened because I saw someone demo a CLI-based AI tool. I do not remember the exact video or post, but I remember the reaction: “Wait, it can just… read your files and make changes directly?”

Curiosity took over. I installed Claude Code first, then OpenCode, then Gemini CLI. Within a week, my relationship with AI had fundamentally changed.

The difference is structural, not incremental. In the browser, AI is a conversation partner. In the terminal, AI is a co-builder. It lives where your work lives.

Here are three concrete things I built that would have been impossible with browser-based AI:

1. Analyzing 660,000 AI Chatbot Sessions

For an AI product I built that serves over 200K users, I needed to analyze 660,000 sessions containing 1.2 million conversations. With 4.6GB of raw data, even loading it into a browser-based tool was impractical.

With Claude Code, I described what I wanted to understand and built this entire pipeline from my terminal:

The analysis revealed patterns I had not anticipated: rural female students showed more quick clarification behavior, struggling learner patterns were twice as common in rural areas, and students used the AI for fundamentally different purposes depending on their subject.

2. A Spend-Tracking Android App

I wanted a simple personal tool: read my Standard Chartered bank SMS, parse each transaction, and show spending in a dashboard. Instead of writing a PRD and handing it to a developer, I described what I wanted to an AI tool in my terminal.

It built the entire Android app. I did not write a single line of Kotlin. But I made every product decision.

The iterative loop was faster and more direct than anything I had experienced, even working with human developers. Describe a feature, test it on my phone, describe what to change, see it fixed immediately.

3. My Portfolio Website

The site you might be reading this on was built the same way. Astro, React islands, MDX content, Vercel deployment. The interactive charts on my project pages, the scroll-triggered animations, the data visualization components: all built through terminal conversations.

The architecture decisions were mine. The implementation was handled by AI. When something did not look right on mobile, I described the change and iterated until it matched my vision.

What It Did to My Team

The personal projects were impressive to me, but the biggest impact was on how my product team works.

We used to start every feature with a dense, multi-page PRD. Stakeholders would read it (or more often, skim it), try to mentally visualize the user flows, and give feedback based on their imagination of what the product would look like.

Now, we demo first.

Before any stakeholder review, the PM responsible builds a functioning prototype using whichever AI tool they prefer. Some use Cursor. Some use v0.dev. Some use Lovable. I use Claude Code. The tool does not matter. What matters is that everyone clicks through actual user flows during the meeting instead of reading about them.

The shift from “writing first” to “demo first” had a surprising side effect: it sharpened our product thinking. When you actually click through what you have designed, the gaps in the user journey become immediately obvious in ways that no document could reveal.

PRDs are not dead. They still matter for complex decisions, compliance requirements, and long-term documentation. What changed is the order: demo first, document later.

Getting Started: A Guide for Curious PMs

If you are a PM or non-engineer who wants to move beyond browser AI, here is what I would suggest:

Start with one small personal project. Do not start with work. Build something for yourself: a personal site, a data analysis, a small utility. The stakes are low and the learning is high.

Learn to give good context. The biggest skill shift is not technical. It is learning to describe what you want clearly and completely. Think of it as writing a really good user story, but for an AI pair programmer.

Do not expect magic. AI tools make mistakes. They write buggy code. They misunderstand requirements. The skill is in reviewing, guiding, and iterating. You are the product manager of the conversation.

Try multiple tools. Each has strengths. Cursor feels familiar if you have used an IDE before. v0.dev requires zero setup for UI work. Claude Code and OpenCode give you the most control from the terminal. Experiment and find what fits your workflow.

Lessons Learned and What Is Next

The journey from browser to terminal was not smooth. Here is what I got wrong and where I think this is heading.

The question is no longer whether PMs should learn to use AI tools beyond the browser. The question is how quickly you can make the shift.

If you want to see what I have built, visit rifatbinalam.com. If you want to talk about AI tools for product teams, reach out on LinkedIn.