I Vibe Coded my own Dynatrace training course
The following is an AI generated summary of the video
Recently, I failed a Dynatrace certification exam.
Not because the training material was bad.
Not because the platform was bad.
Mostly because I underestimated the exam and didn't fully understand what I was walking into.
Afterwards, I went looking for practice questions, mock exams, and training resources that would help me prepare properly.
I couldn't find what I wanted.
So I built it myself. :contentReference[oaicite:0]{index=0}
The Problem
The official training material was useful, but I didn't feel it reflected the complexity of the certification exam.
I wanted:
- Realistic practice questions.
- Multiple categories.
- Explanations for answers.
- Customisable quiz lengths.
- Something I could use repeatedly for short study sessions.
Most importantly, I wanted a tool that matched how I learn.
When I couldn't find one, I decided to create one. :contentReference[oaicite:1]{index=1}
Starting With a README
What's interesting is that I didn't start by writing code.
I started by writing a specification.
I created a Git repository and wrote a detailed README describing:
- The purpose of the application.
- The question formats.
- The workflow.
- The categories.
- The technology stack.
- The user experience.
Essentially, I wrote what would normally become a ticket or requirements document for a junior developer.
Then I handed it to an AI coding tool and waited to see what happened. :contentReference[oaicite:2]{index=2}
The AI Built the First Version
The initial result was surprisingly good.
The AI generated:
- A working quiz application.
- HTML, CSS, and JavaScript.
- Placeholder questions.
- A usable interface.
- A complete pull request.
Within a short time I had something I could actually run and evaluate.
Instead of spending a day or two building the scaffolding myself, I was immediately reviewing a working application. :contentReference[oaicite:3]{index=3}
Iterating Like a Product Owner
The next step was moving questions into JSON files.
Again, I didn't write the implementation.
I described what I wanted.
The AI updated the application, modified the README, created the JSON structure, and adapted the code accordingly.
At that point I realised my role had changed.
I wasn't primarily acting as a developer.
I was acting as a product owner.
My job was defining requirements, reviewing output, and steering the direction of the project.
The AI handled most of the implementation. :contentReference[oaicite:4]{index=4}
Generating Real Questions
Once the application framework existed, it needed actual training content.
I asked the AI to generate certification-style questions based on the official documentation.
Initially this proved difficult.
Large batches would time out.
The solution was simple: break the work into smaller chunks.
Rather than generating hundreds of questions at once, I generated them category by category.
Eventually I had a substantial bank of realistic practice questions covering multiple areas of the platform. :contentReference[oaicite:5]{index=5}
Making It Flexible
One thing I quickly realised was that I didn't want to sit through hundreds of questions every time I studied.
Sometimes I only wanted a quick five-minute refresher.
So I added configurable quiz sizes.
The application could now generate:
- One question per category.
- Three questions per category.
- Five questions per category.
- Ten questions per category.
Again, this was implemented largely through conversation and iteration rather than direct coding. :contentReference[oaicite:6]{index=6}
Unexpected Bonus Projects
Once the framework existed, creating new quizzes became trivial.
I produced:
- A Dynatrace certification trainer.
- A hamster quiz for one of my children.
- A Lilo & Stitch quiz for another.
The underlying application stayed exactly the same.
Only the question sets changed.
What began as a certification tool had accidentally become a reusable quiz platform. :contentReference[oaicite:7]{index=7}
The Strange Feeling of Not Writing Code
Perhaps the most interesting part of the project wasn't technical.
It was emotional.
I didn't write a single line of code.
Not one.
I wrote requirements.
I reviewed pull requests.
I guided implementation.
I tested behaviour.
But the actual coding was performed by the machine.
As someone who has spent decades writing software, that's a strange experience.
There's a genuine sense of loss attached to watching a skill you've invested years developing become partially automated. :contentReference[oaicite:8]{index=8}
From Coding to Directing
This project reinforced a theme I've been thinking about a lot recently.
Software professionals are increasingly moving from implementation towards direction.
The valuable skill isn't necessarily typing code.
It's being able to:
- Define problems clearly.
- Communicate requirements precisely.
- Evaluate solutions critically.
- Spot mistakes.
- Understand trade-offs.
The code still matters.
But increasingly, the ability to describe what should be built matters just as much. :contentReference[oaicite:9]{index=9}
AI as a Force Multiplier
What impressed me most wasn't the quality of the generated code.
It was the speed.
A project that would probably have taken me a day or two to build manually took a couple of hours of intermittent interaction.
Not hours at the keyboard.
Hours of occasionally checking progress, reviewing results, and refining requirements.
The AI wasn't replacing expertise.
It was multiplying productivity. :contentReference[oaicite:10]{index=10}
Final Thoughts
The irony is that I built a training tool to avoid spending too much time building a training tool.
And it worked.
I now have a custom study platform tailored to exactly how I like to learn.
More importantly, the project taught me something about the future of software development.
The biggest shift isn't that AI can write code.
It's that we're increasingly learning how to collaborate with systems that can.
For now, I'm comfortable treating AI like a team member.
I write the ticket.
It proposes the implementation.
I review the pull request.
And together we get the job done a little faster than either of us could alone.