DEV Community

πŸŽ“ Navid Ishaq
πŸŽ“ Navid Ishaq

Posted on Edited on

I Don't Write Python Code. But I'm Building a Python Learning Platform.

33 lessons implemented. 100 lessons planned. One ongoing experiment in AI-assisted software creation.

The interesting part isn't that AI can generate code. It's what happens when product thinking, testing, and engineering meet.

There's an interesting question emerging in software development:

How much programming knowledge does someone need before they can meaningfully contribute to building software?

A few years ago, my answer would probably have been: quite a lot.

Today, I'm exploring a different possibility.

I don't write Python code independently. Yet I'm building an interactive platform for learning Python, with AI assisting in the implementation.

That might sound contradictory. To me, it's an experiment in how software gets created.


01 β€” The project, at a glance

Python DeTLeng is an interactive learning platform designed to help learners explore Python through explanations, executable examples, exercises, and challenges.

Project snapshot Current status
Course roadmap 100 lessons planned
Lesson content implemented 33 lessons (1–33)
Remaining lesson content 67 lessons
Python execution In-browser, using Pyodide
Learning activities Examples, practice, quizzes, and challenges
Progress Stored locally in the learner's browser
Development approach Product-led, AI-assisted, iterative

Explore the project:

A note on scope: The repository contains lesson content for lessons 1–33 and an implemented shared learning engine. This is an evolving projectβ€”not a claim that all 100 lessons are complete or that every feature has been independently browser-tested.

A simple view of the learning experience

   LEARNER
      |
      v
+-----------------------+
|  Explanation & example|
+-----------+-----------+
            |
            v
+-----------------------+
|  Edit and run Python  |
|  in the browser       |
+-----------+-----------+
            |
            v
+-----------------------+
|  Observe the output   |
|  and try variations   |
+-----------+-----------+
            |
            v
+-----------------------+
|  Practice / quiz /    |
|  challenge            |
+-----------+-----------+
            |
            v
+-----------------------+
|  Save local progress  |
+-----------------------+
Enter fullscreen mode Exit fullscreen mode

This is a conceptual learning flow, not a claim that every activity follows exactly the same sequence.


02 β€” My role isn't to pretend I know Python

I approach this work through product design, learning experience design, and iterative experimentation.

I begin with questions like these:

  • What should a learner see first?
  • What happens when they change a line of code?
  • How can an exercise encourage exploration rather than memorization?
  • What should happen when a learner makes a mistake?
  • Can a shared lesson structure support increasingly complex topics?

Those questions become product requirements. AI coding tools help translate the requirements into an implementation.

But generating code is only one part of the process.

The result still needs to be examined, tested, questioned, and revised. Sometimes the implementation follows the prompt but misses the intended experience. Sometimes a new feature introduces an unexpected problem elsewhere.

And sometimes the AI gives a wonderfully confident explanation of a solution that the next test immediately disproves.

That's when a cup of tea helps. So does debugging.

Expand: What does an AI-assisted iteration actually look like?

A simplified example of the workflow:

  1. Define the learner's problem. The exercise should explain a mistake without revealing the full answer immediately.
  2. Specify the experience. Describe what feedback should appear, when hints are offered, and how the learner can retry.
  3. Ask AI to implement. Work from the existing lesson engine rather than creating a disconnected feature.
  4. Test the behavior. Try correct answers, wrong answers, empty input, and unexpected cases.
  5. Review and refine. Update the design or implementation when the result misses the goal.

This is an illustration of the approach, not a formal record of a specific completed test.


03 β€” AI can generate code. It cannot own the product decisions.

Consider a seemingly simple instruction:

Build an interactive Python lesson.

That leaves several important questions unanswered.

Product question Why it matters
Who is the learner? Determines the starting level and language of explanations
What do they see first? Shapes cognitive load and confidence
What happens on error? Determines whether a mistake becomes a learning opportunity
When should hints appear? Balances support with independent problem-solving
How is progress represented? Makes the learning journey understandable

AI can propose answers, generate alternatives, and implement them. But someone still needs to set the goals and evaluate the trade-offs.

For my projects, that's the responsibility I try to take seriously.

The collaboration model

  HUMAN: PRODUCT DIRECTION               AI: IMPLEMENTATION SUPPORT
  ------------------------               --------------------------
  Learner needs                          Code generation
  Learning objectives      <-------->    Implementation options
  UX decisions                           Refactoring assistance
  Acceptance criteria                    Debugging suggestions
  Evaluation and feedback                Technical explanations
                 \                       /
                  \                     /
                   v                   v
                  +---------------------+
                  |  TEST, LEARN, REVISE |
                  +---------------------+
Enter fullscreen mode Exit fullscreen mode

The important distinction: Assistance with implementation does not transfer accountability for product quality to the AI.


04 β€” The first version is not the finish line

AI-assisted development can make a first prototype surprisingly accessible.

The harder questions often arrive afterward:

  • Will the architecture remain manageable as the lesson library grows?
  • Does a change to the shared engine affect existing lessons?
  • Are failures understandable and recoverable?
  • Can someone else inspect and maintain the code?
  • What happens when an AI-generated solution is plausible but incorrect?

These are not small details. They're part of software engineering.

Prototype β‰  production-ready software.

Working once is not the same as being secure, maintainable, accessible, and reliable over time.

I don't see AI-assisted building as a shortcut around these responsibilities. I see it as an entry point that makes learning about them more urgent.

Expand: A practical review checklist for AI-generated features

  • [ ] Does the feature meet the intended user need?
  • [ ] Does it work for expected inputs?
  • [ ] What happens with empty, incorrect, or unusual inputs?
  • [ ] Does it break an existing flow?
  • [ ] Are errors explained clearly?
  • [ ] Are security and privacy implications understood?
  • [ ] Is the implementation readable enough to maintain?
  • [ ] Can the change be tested again after future updates?

A checklist is a starting point, not a substitute for proper engineering review.


05 β€” A different entry point into software creation

I don't see AI-assisted builders and experienced software engineers as competing categories.

They can bring different strengths to the same problem.

Product-oriented perspective Engineering perspective
What problem should we solve? What is a robust way to solve it?
Who will use this? What constraints must the system satisfy?
How should it feel to use? How will it behave under real conditions?
What should we test with learners? How will we verify correctness and reliability?
Which experience is worth building? How can it be built and maintained responsibly?

These perspectives overlap, and many people work across both. The point is not to divide people into fixed roles.

The point is that useful software benefits from multiple kinds of expertise.

AI tools are allowing more people to join the process with something tangible: a prototype, an experiment, or an early product that others can inspect and improve.

That does not make engineering expertise less valuable. It creates more opportunities for that expertise to connect with ideas from outside traditional development backgrounds.


06 β€” What I'm trying to learn

Python DeTLeng is an educational project, but it is also a practical experiment in AI-assisted product development.

I'm interested in understanding:

  1. How far clear product requirements can take an AI-assisted implementation.
  2. Which decisions still require the most human judgment.
  3. Where AI-generated solutions become difficult to maintain.
  4. How testing can improve both the product and the instructions used to build it.
  5. How people with different technical backgrounds can collaborate more effectively.

I don't have definitive answers. That's precisely why I'm building and sharing the work.

The source is available for anyone who wants to examine the approach, raise a concern, or suggest a better engineering decision.


07 β€” A question for developers

I respect the depth of knowledge involved in professional software engineering.

I also think we're entering a period where the ability to create useful software is becoming more widely distributed.

So I'd like to ask:

As AI takes on more code generation, which human skills become more important in building reliable, useful software?

System design? Problem definition? Testing and verification? User experience? The ability to challenge AI-generated decisions?

Probably some combination of all of them.

I'd genuinely like to hear how experienced developers see this changing.

For now, I'll keep designing, experimenting, testing, and learningβ€”and occasionally making tea while the next build runs.

Try it: Python DeTLeng

Read the code: GitHub repository


About the Author

Muhammad Naveed Ishaque is a multidisciplinary thinker, educator, and founder of the DeTLeng Ecosystem, exploring AI, data, technology, business, and human-centered innovation through continuous learning and practical research.

🌐 Explore DeTLeng: www.detleng.com

My collaboration with AI is an ongoing practice of asking better questions, testing ideas, examining results, and improving what doesn't work. The value lies not in assuming either side has every answer, but in remaining curious and accountable throughout the process.

The question I return to most often is β€œWhy?” AI helps me explore possible answers and turn some of them into working experiments. The learning happens when those experiments meet realityβ€”and we pay attention to what needs to change.

Top comments (1)

Collapse
 
navidishaq profile image
πŸŽ“ Navid Ishaq •

Thanks for reading! πŸ‘‹

I'm exploring AI-assisted software development from a product design and learning experience perspective.

Python DeTLeng currently has 33 implemented lessons, with a 100-lesson roadmap. It's an evolving experiment, and I'm particularly interested in improving its architecture, usability, and reliability.

A question for experienced developers: When working with AI-generated code, what do you consider the most important skill to develop first β€” understanding the architecture, writing effective tests, or learning to review the code critically?

I'd genuinely appreciate your perspectives. I'm here to learn, build, and exchange ideas.

And yes, tea is part of the workflow. β˜•πŸ™‚