AI has been everywhere in software lately, but AI Coding is not one single practice. It comes in different levels and each level creates value in a different way.
With 25 years in engineering (Dev → Team Lead → Technical Solution → CTO → Software Development Company Owner) and 200+ projects delivered across a wide range of complexity, many of them using AI coding assistants. I’ve seen AI support coding through distinct usage levels, from boosting an individual developer’s speed to reshaping how an organization delivers software.
Below are the six levels I’ve observed. Among them, LEVEL 3 and LEVEL 4 are the ones WeebPal Technology Corporation has officially adopted for new projects since late 2025.
LEVEL 1: AI CODES A FUNCTION/SNIPPET
User: Developer
Input: One prompt that clearly defines the goal, logic, and inputs/outputs
Output: A standalone function or snippet for a specific need
Testing: The developer reads, runs, and verifies the output
Best for: helpers, parsing/formatting, data mapping, small algorithms
At this level, each prompt produces a function or snippet. This is the level that almost any developer can start using immediately, with minimal preparation. It is often used “spontaneously”: whenever a small piece of logic needs to be written quickly and correctly, the developer asks AI to generate it.
The clearest benefits of LEVEL 1:
A significant speed-up for “small but must-be-correct” coding tasks.
The code often looks “cleaner,” because AI tends to apply best practices in naming, structure, and basic edge-case handling.
For junior developers, it can be a fast learning method, seeing well-structured examples directly.
However, from an organizational software delivery perspective, LEVEL 1 does not create a major change. It makes individuals faster, but it’s not enough to become a “systematic” delivery method for the company.
Therefore:
This is not an official WeebPal process level.
But developers are allowed to use it proactively as “personal tooling” when it fits the problem.
LEVEL 2: AI CODES A COMPLETE CLASS/COMPONENT
User: Developer
Input: A prompt defining the class/component + iterative prompts to add variables/methods when needed
Output: A class/component with multiple methods that serves a specific need
Testing: The developer reads, runs, and verifies it in the project context
Best for: service classes, validators, transformers, repositories, adapters
LEVEL 2 is a broader version of LEVEL 1: instead of asking AI to write a small function, the developer asks AI to write a complete class or component.
LEVEL 2 still brings real benefits:
Faster implementation
Better formatting and structure
A fairly solid code skeleton (especially for familiar patterns)
But LEVEL 2 begins to surface practical challenges:
Prompting becomes harder: The developer must describe responsibilities, method lists, parameters, constraints, and boundaries. If those are missing, AI will “fill in” with assumptions, significantly increasing the risk of drifting away from the real requirement.
The cost of understanding + editing + testing increases: To make an AI-generated class usable in a real project, a developer often has to: read all of the generated code carefully, adjust it to project conventions, add missing methods, test it with real use cases, fix project-specific edge cases not covered in the prompt
In total, the time may not always be better than writing it manually, especially with complex domain logic or heavy integrations.
Therefore, similar to LEVEL 1, LEVEL 2 is often used as an “individual acceleration” technique, and WeebPal does not treat LEVEL 2 as an officially adopted process level.
LEVEL 3: AI CODES AN END-TO-END FEATURE FLOW (FORM, PAGE, BLOCK, COMMAND, …)
User: Developer
Input: One prompt that fully describes the feature requirements (UI/behavior + data + routing/menu/permission + service handling)
Output: A complete flow: routing/menu/permission + form/controller/block + service + command + (unit tests if needed)
Testing: Put it directly into the project to run; review key points; ask AI to fix iteratively as needed
Best for: CRUD with workflow, permissions, menu items, multi-step business logic; especially suitable for Drupal 11 architecture
This is the biggest leap in “organizational value.”
At LEVEL 3, a prompt is no longer “write me a piece of code,” but “implement a complete feature following the architecture.”
For example: build a form that loads fields from data, uses a service for processing, provides a command for batch execution, and includes proper routing/menu/permissions.
In practice, with LEVEL 3:
A single request can generate hundreds to thousands of lines of tightly connected code end-to-end.
It can include dozens of methods working together.
It can create everything a feature needs: form/controller/service/command, routing, menu, permissions… depending on the architecture you specify.
Why is LEVEL 3 especially suitable for WeebPal?
It fits Drupal 11 extremely well (module/service/form/controller/command is already a standardized structure).
Developers focus on what matters most: finalizing the flow, locking the DoD, locking integration points; AI generates the pattern-based skeleton very fast and often quite clean.
The completion process is disciplined: each feature has acceptance criteria, test scenarios, and a delivery checklist.
This is the level WeebPal officially applies to all new projects since late 2025.
LEVEL 4: AI SUPPORTS BUILDING AN ENTIRE PROJECT
User: Solution Architect
Input: A set of prompts to define architecture, data, sitemap, entities, modules, forms, controllers, blocks, services, commands…
Output: A “ready-to-develop” system: clear architecture + entity/module map; decomposed into LEVEL 3 tasks for developers
Testing/Acceptance: CI/test suite, security/performance checks, UAT plan by milestones
Best for: large projects, many integrations, data-heavy systems, complex logic, high risk
LEVEL 4 is where the problem is no longer “one prompt,” but “a system” driven by someone capable of defining architecture and execution strategy.
At this level, AI is not used as “type one prompt and get the entire project.” Instead:
The project is designed at a system level: define entities, define module boundaries, define controllers/services/forms, define integrations, define migrations…
Then the system is decomposed so developers implement via LEVEL 3 (feature-by-feature, module-by-module).
Key differences:
The Solution Architect is responsible for orchestration: architecture, boundaries, risks, performance, security, operations, rollout plan.
Developers use AI at LEVEL 3 to deliver quickly and complete each feature according to the project requirements.
This is also a level WeebPal officially applies for new projects since late 2025.
LEVEL 5: AI CODES A COMPLETE PROJECT WITH ONLY A SOLUTION ARCHITECT (NO DECOMPOSITION INTO LEVEL 4 + LEVEL 3)
User: Solution Architect
Input: Multiple prompts to define architecture, data, sitemap, entities, modules, forms, controllers, blocks, services, commands…
Output: With Drupal 11, AI can implement a large portion of the functionality following the architecture defined by the Solution Architect
Testing/Acceptance: CI/test suite + milestone-based quality checks; continuous AI-driven fixing until completion
Best for: standardized architecture, clear scope, familiar domain; optimizing speed while maintaining architectural control
At this level, the Solution Architect plays the “architect” role, while AI plays the “delivery team.” Instead of decomposing and assigning developers to implement features at LEVEL 3, the SA defines architecture, boundaries, module maps, coding standards, and acceptance checklists and works directly with AI to implement the project by milestones or by modules.
The core difference of LEVEL 5 is this: the process no longer includes feature-by-feature implementation by developers at LEVEL 3. AI becomes the direct “dev team” under SA coordination.
As of now (12/2025), from my perspective, OpenAI can only cover part of this level and it is not mature enough for LEVEL 5 to run end-to-end reliably for complex projects.
Rather than waiting for LEVEL 5 to fully mature, WeebPal is experimenting with a “LEVEL 4++” direction: we still decompose projects into LEVEL 4 and LEVEL 3, but we focus on optimizing efficiency and stability at LEVEL 3 first. Once LEVEL 3 becomes highly stable and models continue to evolve, “approaching LEVEL 5” will happen naturally.
LEVEL 6: AI CODES A COMPLETE PROJECT FROM BUSINESS REQUIREMENTS
The ideal form of AI coding, this level still needs time for AI to reach real-world scale and complexity.
Users: Business Owner / Product Owner / Business Analyst / Project Manager
Input: Business Requirements (in natural language or structured logic) + clear DoD
Output: A complete software system
Testing/Acceptance: AI repeats plan → implement → test → fix → converge according to DoD; passes quality gates (CI/tests/security/performance)
Best for: standardized project scope, extremely familiar domains, strong “productized” engineering standards
This is the highest level: with Business Requirements (plus a clear Definition of Done), AI can design sufficiently, implement, test, fix, and converge until it produces a complete product.
However, for LEVEL 6 to be feasible, multiple conditions must come together:
The software platform must be complete: it provides enough universal tools to solve user logic problems. (From my view, many platforms are close to this, and Drupal 11 is a strong example.)
A large enough volume of completed projects must exist for AI to learn real implementation patterns.
AI must evolve in both models and infrastructure to handle broad problems: many variables, many steps, and many constraints.
The people driving the project must evolve enough to use AI effectively at this level.
From LEVEL 1 to LEVEL 6, one rule is very clear:
The higher the level, the greater the organizational value.
The higher the level, the stricter the standardization requirements.
At WeebPal, we do not treat AI as merely a tool to “code faster.” We treat AI as part of our delivery capability. But for AI to create real business value, it must be used at the right level by the right role and within the right operating model:
LEVEL 1–2: suitable for individual acceleration and learning, but not an official organizational process.
LEVEL 3–4: where AI creates real organizational change (standardization, completeness, acceptance, scalability), and why WeebPal officially adopted them since late 2025.
LEVEL 5–6: the next evolutionary direction. Today, we actively experiment, optimize “LEVEL 4++,” and closely track how models mature, so we can upgrade our process when the conditions converge.
For me, AI does not replace thinking and architecture, AI amplifies the value delivered by thinking and architecture.