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 |
+-----------------------+
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:
- Define the learner's problem. The exercise should explain a mistake without revealing the full answer immediately.
- Specify the experience. Describe what feedback should appear, when hints are offered, and how the learner can retry.
- Ask AI to implement. Work from the existing lesson engine rather than creating a disconnected feature.
- Test the behavior. Try correct answers, wrong answers, empty input, and unexpected cases.
- 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 |
+---------------------+
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:
- How far clear product requirements can take an AI-assisted implementation.
- Which decisions still require the most human judgment.
- Where AI-generated solutions become difficult to maintain.
- How testing can improve both the product and the instructions used to build it.
- 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)
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. βπ