Learning to Code with AI: 3 Critical Lessons from a Hackathon

With the rise of generative AI, programming education has undergone a dramatic transformation.

While AI brings significant advantages to coding, it also presents unique challenges for genuine learning.

Through my experience with a full-stack hackathon project, I learned three critical lessons about effectively balancing AI assistance with genuine skill development.

The Benefits and Pitfalls of Programming with AI

The biggest advantage of programming with AI is speed.

Whenever I encounter a challenge, defining the issue and the initial situation is much easier than translating it into precise Google search queries.

AI can understand even poorly constructed, half-natural-language, half-programming gibberish and usually provides something useful or at least relevant.

The less experience you have, the more impressive and convenient this becomes.

I challenged myself by undertaking a full-stack hackathon.

I needed to create a working backend (written in Kotlin) to handle game logic and a website (pure HTML and JavaScript) to serve as the game UI.

I had no prior experience with either.

To start, I described my high-level plans to ChatGPT and let it generate suggestions.

It recommended using the Ktor framework (a Kotlin backend framework with REST API and WebSocket support), Freemarker for the frontend (later replaced with pure HTML and JS), and JavaScript to connect the two.

At first, the experience was amazing. I quickly completed minor tasks: setting up the local backend, displaying my first “Hello, World!” webpage, and adding basic JavaScript just to experiment.

I felt like a programming god. But it was a trap. I wasn’t paying enough attention to system cohesion, architecture, or reusability.

Soon, the initial speed turned into an unmaintainable mess, and even ChatGPT started confusing itself with its code.

Lesson 1: Keep Control Over AI

I scrapped the initial project and started over. This time, I used ChatGPT only to help set up the project and guide me to the “Hello, World!” stage.

From that point on, I asked specific questions and requested help with isolated tasks, providing only the necessary context.

This approach gave me more control over the system.

However, as I progressed, ChatGPT accumulated more context and started making assumptions, sometimes introducing errors in areas I hadn’t specified.

During the hackathon, my workflow was as follows:

1. Plan a new feature or mechanism.
2. Implement the barebones structure on the backend.
3. Build a basic static frontend.
4. Connect the two components.
5. Tweak the implementation until it is complete.

ChatGPT adapted to this process but often tried to anticipate future steps instead of focusing on my immediate requests.

While doing so, it sometimes lost important context from previous tasks, such as frontend styling rules or API endpoint structures.

This was frustrating, as I had to remind it and enforce consistency.

Lesson 2: Threading AI Conversations

To solve these context issues, I structured conversations into threads.

For the hackathon project, I set up three separate threads with ChatGPT:

• Backend Thread: Focused solely on Kotlin-related tasks. I avoided mentioning frontend concerns.
• UI Thread: Handled HTML design, embedded CSS, and basic JavaScript (limited to on-site behavior, no networking).
• Integration Thread: Managed communication between the backend and frontend.

Each thread contained only the necessary context, keeping the conversations within ChatGPT’s memory limits.

In addition to these three main threads, I created several smaller conversations for minor questions.

It proved useful and let me finish that project on time.

But this setup had two challenges:

1. I had to be mindful of switching between threads correctly.
2. Occasionally, I had to copy and paste information between threads to maintain proper context.

Lesson 3: AI Doesn’t Replace Real Learning

While AI accelerated my coding process, I noticed that my actual knowledge was weak and shallow.

I could implement features with AI’s help, but I wouldn’t have been able to recreate them from scratch without assistance.

Coding with AI does not provide as much experience as working from documentation, debugging independently, and experimenting with solutions.

Traditional problem-solving—searching for solutions, reading multiple imperfect approaches, finding “close enough”, and tweaking it for a specific case—requires more effort but leads to deeper learning.

Since the hackathon, I have started learning cross-platform mobile development with React Native.

I still use ChatGPT extensively, but I’ve established rules for myself to ensure I genuinely learn the framework:

• Not solving complex cases with AI. I force myself to break down challenges into smaller parts and only seek help for blockers. Anything I can do independently, I do manually.
• Minimal context-sharing. I try to get generic solutions from AI and adapt them to my project rather than providing full context.
• One-time AI usage per problem. If I remember solving an issue with AI, I force myself to find the previous solution in my code instead of asking ChatGPT again.

These restrictions wouldn’t be feasible in a real-world SaaS development project, where time is a valuable resource.

In professional work, I would likely provide more context and seek tailored solutions from ChatGPT.

However, for learning purposes, these limitations help me build real experience rather than relying too much on AI.

Conclusion

Through my hackathon experience, I discovered that effectively learning with AI requires a deliberate approach: maintaining control over AI’s suggestions, organizing conversations by domain, and setting clear boundaries for AI assistance.

While AI accelerates development, true expertise still demands hands-on problem-solving and concentrated practice.