Over the recent holiday period, I decided to use my portfolio website as a guinea pig for a personal upskilling experiment. My goal was simple: progress from Level 1 (Code Completion) to Level 2 (Human-Directed Local Agents) in my understanding and use of AI tools. Building this entire portfolio with Claude in VS Code turned out to be the perfect learning project.
The Gap in Available Training
I recently completed IBM's "Generative AI for Data Engineers" certificate, which provided valuable foundations—but it was heavily focused on Level 1 capabilities. The course primarily covered copy-pasting code from LLMs, using prompts to generate snippets, and understanding basic AI interactions. Useful, absolutely. But it left me wondering: what comes next?
Level 2 and beyond represent extremely new and cutting-edge territory. There are limited resources, few established best practices, and hardly any structured training available. Most Level 1 training teaches you to use AI as a smart autocomplete or a code snippet generator. But Level 2—where you're directing an AI agent with full repository context—is fundamentally different.
The only way to truly upskill at this frontier is through experimentation. You need to build something real, observe what works and what doesn't, and develop intuition through hands-on practice. That's why I chose to build my portfolio website as the learning vehicle.
The Learning Objective
I've been using AI code completion tools for a while—helpful autocomplete suggestions, snippet generation, that sort of thing. But I wanted to understand what changes when you give an AI assistant full repository context. What does Level 2 actually feel like compared to Level 1? What new capabilities unlock? And critically, what limitations or challenges emerge?
Since I'm not a web developer, building a portfolio site from scratch seemed like an ideal challenge—complex enough to be meaningful, but not so critical that mistakes would matter. A safe environment for experimentation where I could learn through doing.
Why Repository-Centric?
I'm particularly keen on the repository-centric approach for a straightforward reason: context is everything. When your AI assistant has access to the entire project—code, documentation, configuration files, and all—it can make decisions that align with your project's structure and patterns. Everything stays source-controlled by default, creating a natural audit trail.
For this project, I tested several tools: Anthropic's Claude, GitHub Copilot, and Cursor—all with very similar results. I prefer working in VS Code because it allows me to interchange between different AI options, keeping my workflow flexible rather than locked into a single vendor's ecosystem.
This contrasts with in-editor AI tools where each interaction exists in isolation. Those tools are great for what they do, but they can't simultaneously update your documentation when they write code, or ensure consistency across multiple files. They're Level 1—helpful, but limited in scope.
What I Learned: The Benefits
Working with repository-centric AI tools across my entire project revealed capabilities I hadn't fully appreciated:
- The AI could write HTML while simultaneously updating related CSS, keeping the design consistent without me manually coordinating between files
- It followed project-specific conventions by learning from existing code—once I established a pattern, it maintained that pattern throughout
- Documentation and code stayed in sync because the AI could update both simultaneously
- I could describe high-level goals ("make the navigation responsive") and the AI would handle implementation details across multiple files
This holistic approach meant I spent less time on tedious coordination work and more time on creative decisions and learning.
Quality Control and Guardrails
One concern with AI-generated code is quality. The repository-centric approach naturally supports proper guardrails. I configured my workflow so the AI could only work locally—it couldn't push directly to my main branch. This created a "human in the loop" checkpoint where I reviewed everything before publishing.
This workflow felt like collaborating with a very capable but junior team member: I provided context and direction, the AI worked autonomously, and I reviewed the output. The difference is AI never gets tired and can work across the entire codebase simultaneously.
The Portfolio Project: Vibe-Coding to a Solution
I'll be honest: I'm not a web developer. If I'd tried to build this portfolio from scratch the traditional way, it would have taken considerably longer and likely looked far worse. A professional web developer would undoubtedly produce something more polished.
But that wasn't the point. This was about learning Level 2 capabilities—understanding what "vibe-coding" with an AI agent actually feels like. I provided high-level direction and architectural decisions. The AI handled implementation details, maintained consistency, and optimised for GitHub Pages hosting.
The entire website came together over a few days of casual holiday work. More importantly, I now understand the practical differences between Level 1 and Level 2, which informs how I think about using these tools professionally.
Looking Ahead: Professional Applications
This was a personal learning project, not a professional one. But I'm keen to see how these capabilities might translate to my professional work. The ability to maintain consistency across complex projects, keep documentation in sync with code, and work at a higher level of abstraction—these feel like valuable skills worth developing further.
Of course, professional contexts bring different requirements, constraints, and quality standards. That's why this was an experiment with my personal portfolio rather than a production system. But as a learning vehicle, it served its purpose perfectly.
The Maturity Journey: Understanding the Levels
Through this project, I've gained practical experience with the progression from Level 1 (Code Completion) to Level 2 (Human-Directed Local Agents). At Level 1, AI suggests code snippets and completions within your editor—helpful, but limited in scope. At Level 2, you're directing an AI agent that can work across your entire local repository, understanding context, maintaining consistency, and handling multiple related tasks simultaneously.
To be completely transparent: this portfolio project demonstrates core Level 2 capabilities—multi-step workflows, repository-wide context, and autonomous implementation decisions. However, the portfolio's simplicity meant less emphasis on testing and debugging compared to what a production data engineering project would require. While the AI didn't write extensive unit tests or debug complex pipeline failures, it successfully demonstrated the fundamental shift from AI-as-autocomplete (Level 1) to AI-as-collaborative-partner (Level 2).
The learning journey doesn't end here. The remaining progression looks like this:
- Level 3: Human-Supervised Remote Agents — AI agents that can work asynchronously on tasks, potentially across distributed systems, with periodic human checkpoints
- Level 4: Autonomous Engineer — AI that can independently scope, design, implement, and deploy features with minimal human intervention
- Level 5: Autonomous Team — Multiple AI agents collaborating with specialised roles (architect, developer, tester, reviewer) working together on complex systems
Understanding this progression helps frame where current tools sit and where the technology is heading. This project was specifically about mastering Level 2 capabilities through hands-on experience before considering what higher levels might look like.
Final Thoughts
This portfolio project achieved its goal: I now have practical, hands-on experience with repository-centric AI development. I understand the difference between Level 1 and Level 2 not just theoretically, but through actually building something.
The key insight? Giving AI full repository context unlocks capabilities that go beyond code completion. It's not just about writing code faster—it's about working at a higher level of abstraction while maintaining consistency across complex projects.
Whether these skills translate meaningfully to professional work remains to be seen. But as a personal upskilling exercise, this was time well spent. And hey, I got a portfolio website out of it too.
A Final Reveal
Here's the meta part: this entire blog article you've just read was written by Claude, a Level 2 human-directed local agent.
Because this blog post lives in my git repository, Claude had full access to it—along with the entire project structure, commit history, and documentation. I provided the main points I wanted to cover, the tone I wanted to strike, and the key messages about personal learning versus professional application. Claude handled the rest: structuring the narrative, writing the content, maintaining consistency with the site's style, and even crafting this reveal.
This is another example of what's possible with Level 2 capabilities. Not just building a website, but writing about the process of building it—all while staying true to the repository's context, conventions, and goals. The AI understood what I was trying to achieve, adapted to feedback, and produced content that aligned with my voice and intent.
And that, more than anything, demonstrates the power of repository-centric AI development: it's not just about code. It's about working with an AI partner that understands your entire project context and can contribute across all aspects—from implementation to documentation to storytelling.
If you're interested in discussing AI learning approaches or want to share your own upskilling experiments, I'd love to hear from you. Reach out via the contact form or connect with me on LinkedIn.