My personal portfolio started as one HTML page. It held all the content, the CSS and JavaScript were embedded in it, and a standalone PHP contact form sat beside it. The goal was simple: present my professional experience cleanly and publish it.
It worked, and for a site that size that structure was a reasonable choice, not a mistake. What I did not expect was how far the project would travel from there, or that the AI's most valuable contribution would be helping me think rather than typing code.
Starting small, on purpose
The first version only had to be useful. My early conversations with the AI were tactical:
- Improving and tightening the wording
- Adjusting layout and structure
- Improving responsiveness and the user experience
The goal was refinement, not transformation. Perfection was never required to begin, and starting small is what made the later questions possible.
The questions changed
Somewhere along the way, my questions changed. At first I asked, "How can I improve this section?" Later I was asking, "How should this website evolve over time?"
They were about the same website, but they were different kinds of question. The second came from wanting more than one page could comfortably carry: detailed case studies, a potential future blog section, menus with more than one level.
The visible problem is often not the real problem. I thought I needed better styling; I needed a structure that could grow.
I had assumed the task was technical: split a large HTML file into several files. But splitting a file only moves the same content into more places. The real challenge was how to organize the site so it could keep growing and stay understandable, to me and to the AI sessions I was working with.
From a page to a platform
The structure I settled on was a multi-page PHP site on Apache and cPanel. Each major section got its own page. The header, navigation and footer became shared components. The CSS and JavaScript were split into modules, and the navigation was driven by data so it could later grow into nested menus.
I do not think a single page is inherently unable to handle search metadata, analytics or security. This structure simply suited where I wanted this particular site to go. Shared elements stay consistent because they live in one place, a change is made once, and new sections have an obvious home. Concerns such as analytics, search metadata and visitor consent each needed a place to live, and a modular structure gave them one.
It also has a cost: more files, more places to look and more care needed when publishing. Splitting files does not make a system scalable, secure or maintainable by itself. The point was not to add complexity; it was to make future changes easier to reason about.
Iteration, not a rewrite
There was no single dramatic rewrite. The platform grew through successive iterations, each responding to a clearer requirement: introducing shared components, organizing responsibilities more clearly, improving the way changes are made and adding safeguards for security and visitor consent.
Each step made the next question easier to ask. I did not know the final structure at the start; it became clearer as I went.
How the AI helped
I stopped asking the AI to "write this code" and started asking it to help me define the problem:
- Should a portfolio remain a single-page website?
- When does a multi-page architecture become beneficial?
- How should navigation scale as content grows?
- What risks am I overlooking?
- Why are you recommending it that way?
The AI helped me explore alternatives, weigh trade-offs and spot risks I had not considered, and when it recommended something I asked it to explain why. It did not decide what the website should become, define my goals or set my priorities. The direction, the decisions and the checking that the result worked stayed with me. The execution became faster; the responsibility did not move.
Lessons I would pass on
- Start small. The first version only needs to be useful.
- Let iteration create insight. The destination became clearer as I traveled, without a grand plan up front.
- Give the AI context. Recommendations improved sharply once goals, standards and architecture were written down.
- Notice when the problem has changed. A simple solution is not a mistake just because it eventually needs to evolve. The skill is recognizing the moment it does.
- Ask for reasoning, not only code. The best sessions explored options and trade-offs, not just answers.
What began as a portfolio refresh became a lesson in noticing when a problem has changed and asking better questions about the next step. It also exposed a new problem. The reasoning behind each decision lived in conversations that would not carry over to the next session, so the next challenge was making sure the context survived. That is the story of the documentation.