Learning AI Coding with Iszuddin

Published on Tue Nov 11 2025 00:00:00 GMT+0000 (Coordinated Universal Time)

Overview

I recently completed a training session on AI-powered coding through the MyTalent TalentCorp program managed by AGMO Academy, instructed by Iszuddin Ismail. This was an eye-opening experience that completely shifted my understanding of what AI coding assistants can do.

The session wasn't just about writing code—it was about leveraging AI as a comprehensive development partner for a wide range of tasks. Here are the key insights I gained.

1. LLMs and Agent-Edit-Ask Mode: A Game Changer

The session introduced me to the concept of Large Language Models (LLMs) working in agent-edit-ask mode, where the AI takes an active role in development rather than just responding to queries.

What I Learned

An AI agent in "edit-ask mode" can:

  • Propose changes and ask clarifying questions before implementing
  • Understand context from your entire project structure
  • Make educated decisions about architecture and design
  • Iterate intelligently based on your feedback

Real-World Application: Building a Static Site Generator

As a practical exercise, we built a complete static website generator (SSG) from scratch. This wasn't a small tutorial project—it included:

  • Markdown parsing with YAML frontmatter support
  • Template engine with variable injection and includes
  • Automatic HTML generation from markdown content
  • Blog indexing with date-based organization
  • Development server with live preview
  • Responsive design with Tailwind CSS and dark mode support

The Result: A fully functional portfolio and blogging platform built in just a few hours, with all the scaffolding, documentation, and tooling set up automatically by the AI agent.

Key Insight

Working with an AI agent in edit-ask mode meant I didn't have to manually implement every single piece. Instead, I could:

  1. Describe what I wanted
  2. Let the AI ask clarifying questions
  3. Provide answers to refine the approach
  4. Review and approve the implementation
  5. Iterate and improve incrementally

This is fundamentally different from traditional coding—it's more like pair programming with an intelligent partner who anticipates your needs.

2. Beyond Code: GitHub Copilot's Unexpected Capabilities

One of the most surprising revelations was that GitHub Copilot isn't just for writing code. It's a versatile content creation tool.

Slide Library and Presentations

GitHub Copilot can help generate slides for presentations. Instead of manually creating each slide deck, you can:

  • Describe your presentation topic
  • Let Copilot suggest slide structures
  • Generate content for each slide
  • Maintain consistent formatting

This was particularly useful for documenting the SSG project and explaining concepts.

Reports and Documentation (Markdown Format)

Copilot excels at generating comprehensive documentation in Markdown:

  • README files explaining project setup and usage
  • User guides with step-by-step instructions
  • API documentation with proper formatting
  • Technical specifications clearly structured
  • Troubleshooting guides covering common issues

PRD Files (Product Requirements Document)

One of the most powerful applications was using Copilot to generate a complete PRD (Product Requirements Document). The AI could:

  • Understand the project vision from a brief description
  • Ask clarifying questions about features and requirements
  • Organize requirements into logical sections
  • Create acceptance criteria for each feature
  • Generate a roadmap with implementation phases

TODO Lists and Project Management

Similarly, Copilot can generate detailed TODO lists with:

  • Tasks organized by phase or priority
  • Subtasks broken down into actionable items
  • Dependencies and sequencing
  • Time estimates
  • Completion status tracking

Key Insight

GitHub Copilot is a knowledge worker's assistant, not just a code generator. It can handle any task involving written content creation, structure, and organization.

3. The Credit Limit: A Moment of Realization

During the session, I ran out of API credits.

While this was initially frustrating, it was actually valuable because:

  • I realized how much work was getting done through the AI agent
  • It highlighted the importance of planning before execution
  • It showed that even with limited credits, we accomplished an enormous amount
  • It reinforced that efficiency and smart prompting matter

This also made me appreciate the free tier limitations and the importance of being intentional with your queries.

4. Code Examples: The Hands-On Learning

While we didn't focus on specific isolated code examples, the practical exercise of building the static site generator provided real, production-ready code:

  • A complete Node.js generator that processes markdown files
  • Template system with intelligent variable injection
  • Web server for local development
  • Responsive HTML templates styled with Tailwind CSS
  • Comprehensive documentation in Markdown

All of this was created through iterative prompting and refinement with the AI agent, showing how complex projects can emerge from clear communication and feedback.

5. The Biggest Takeaway: What AI Coding Agents Actually Enable

The most important lesson from this session was something I never expected:

I learned things I never thought I could do with an AI Coding Agent.

I assumed AI coding assistants were for:

  • Autocompleting function implementations
  • Fixing syntax errors
  • Explaining code snippets

But the reality is much broader:

✅ Full project scaffolding from concept to working prototype
✅ Architecture decisions informed by best practices
✅ Documentation generation at scale
✅ Comprehensive planning (PRDs, TODOs, roadmaps)
✅ Design system creation with modern frameworks
✅ Content creation beyond just code
✅ Rapid iteration and refinement

What This Means Going Forward

After this session, my approach to development has changed:

  1. Start with clear communication - Describe what you want, not how to build it
  2. Leverage the agent for planning - Get PRDs, TODOs, and architecture before coding
  3. Ask clarifying questions early - Let the AI ask what it needs to know
  4. Iterate incrementally - Build in phases, not all at once
  5. Use AI for documentation - Don't manually write guides that AI can generate
  6. Think bigger - What seemed impossible is now achievable with the right partner

Conclusion

The GitHub Copilot session with Iszuddin Ismail fundamentally changed how I view AI-assisted development. It's not just a code completion tool—it's a comprehensive development partner that can handle planning, coding, documentation, and design.

The static site generator exercise proved that complex projects with proper documentation and tooling can be built in hours, not days. The key is clear communication, iterative refinement, and trusting the AI agent to ask clarifying questions.

For anyone looking to maximize productivity in software development, working with an AI agent in an edit-ask mode is a game-changer. It transforms you from a solo developer into part of a high-functioning development team.

Key Takeaways

  • 🤖 LLMs in agent-edit-ask mode are powerful partners, not just tools
  • 📝 GitHub Copilot extends far beyond code (slides, reports, documentation)
  • 🏗️ Complex projects can be built faster with proper planning and iteration
  • 📋 AI can handle planning artifacts (PRDs, TODOs) as well as implementation
  • 🚀 The real power comes from thinking bigger about what's possible

This article reflects on my learning experience from the MyTalent TalentCorp program managed by AGMO Academy. Special thanks to Iszuddin Ismail for the instruction and guidance.