Self-taught developers should use AI to sharpen judgement, not avoid learning | Rizwan Saleem

Self-taught developers should use AI to sharpen judgement, not avoid learning

AI has changed what it feels like to learn software engineering. A developer can now ask a question and get an explanation, a code sample, a test idea, or a refactor suggestion within seconds.

For self-taught developers, that is a serious advantage.

But it also creates a trap.

If AI becomes a shortcut around understanding, it can make the learning process look faster while making the developer weaker. The output may compile, but the person behind it may not know why it works, what trade-offs it carries, or how it fails under real product conditions.

The goal is not to reject AI. The goal is to use it in a way that builds judgement.

Use AI to ask better questions

A shallow prompt asks for code. A stronger prompt asks for reasoning.

Instead of only asking, “Build this React component,” a developer can ask:

• What state does this component need to handle?
• What edge cases could break this flow?
• What should be typed strictly in TypeScript?
• What accessibility details should I check?
• What is the simplest implementation that will still scale?
• What are the trade-offs between these two approaches?

Those questions turn AI from an answer machine into a learning tool.

Frontend quality is more than the happy path

Frontend engineering is close to the user experience. A small decision can affect trust, usability, and product clarity.

In React, Next.js, and TypeScript work, developers still need to think carefully about:

• loading and empty states
• form validation and recovery paths
• keyboard navigation and accessibility
• data fetching and error boundaries
• performance and bundle impact
• component naming and ownership
• API contracts and user-facing copy

AI can help surface these concerns, but it cannot take responsibility for them. The engineer still owns the outcome.

A better workflow for AI-assisted learning

A practical workflow for self-taught developers is:

1. Try to describe the problem in your own words first.
2. Ask AI to explain the concepts before generating code.
3. Build or modify the first version yourself.
4. Ask AI to review for edge cases, types, tests, and accessibility.
5. Refactor the solution until you understand every important decision.
6. Write down one lesson from the exercise so the knowledge compounds.

This keeps the learning active instead of passive.

The real advantage is disciplined curiosity

My own message is simple: you do not need a perfect beginning to build a serious future. You need curiosity, discipline, ethics, and the courage to keep learning when no one is clapping yet.

AI can support that process. It can speed up research, reduce friction, and expose you to patterns you might not discover alone.

But the durable advantage is still human: disciplined curiosity, technical judgement, and responsibility for the work.

Takeaway

AI can accelerate a self-taught developer’s path, but it should not replace the path.

Use AI to sharpen your reasoning. Use it to test your assumptions. Use it to understand trade-offs faster.

But keep learning the fundamentals. Keep owning the decisions. Keep building the judgement that makes the tool useful in the first place.

---

Rizwan Saleem — https://rizwansaleem.co