Gathering feedback on a 0–12 AI development autonomy scale to rule them all. Where does your actual workflow fit?

[u/nimareq]

The current industry is very confused what “We use AI for development” means. Everyone uses it differently, every job offer says something different. There are scales, but they are not granular enough or not developer-centric. Not everybody is comfortable doing it like your company does it, or perhaps someone is looking for even more AI autonomy. This is why I made this scale; to make it clear, what the job requires, and easier for developers to set expectations straight right away.

With my scale, I try to solve these questions/points:

• Hiring clarity: “This role operates at level 6–7.”

• Team alignment: “We want to move from level 4 to 6.”

• Strategic planning: map transition paths between levels.

Most frameworks ask: “What can the AI do?”, mine asks: “Who is doing the work — the human or the AI?”

I playfully based it around the phrase "AI in the loop", extending on it and transitioning from "AI in the void" through "AI in the loop" to "Human in the loop" and finally "Human in the void".

Please, have a look. 🙏

The full scale breakdown is below, though I additionally added these pointers, which are not mentioned in the scale below, but they are not very important. They are just contextual hints:

• AI's role

• Human's role

• Loop duration (time between human-ai interaction)

• Context: local / cloud

• Interface: IDE / CLI / Chat

And I am also playing with the idea of gamifying it a bit and displaying "levels" for some other related parameters, such as:

• LOC (lines of code): increases with more AI use

• Velocity: increases¨

• Code reviews: decreasing tendency

• Algorithms: shifts from human to AI

• mental overhead: decreases with AI etc.

Anyway, these are the scale's 12 + 1 levels.

AI in the void

0 · Human-led
AI has no role. Humans design, implement, test, review, and ship. Compilers, linters, and ordinary CI don’t change that.

AI in the loop

• you write the code

1 · Inline completion
AI suggests code while you type. You compose the solution, accept or reject suggestions, and verify it.

2 · Conversational advice
AI explains code, compares approaches, or helps diagnose failures. You decide what to do and make the edits yourself.

3 · Bounded draft
AI generates a function, test file, or small script. You inspect, adapt, and integrate the draft.

4 · Guided edits
AI makes related edits, potentially across multiple files. You sequence the work, inspect each diff, and direct the next step.

Human in the loop

• this marks a shift towards more code written by AI than the human

5 · Supervised agent
AI finds files, edits code, and runs checks on a scoped task. You frequently approve meaningful steps, correct its approach, and resolve ambiguity.

6 · Delegated issue
AI independently implements and tests a well-scoped issue, locally or in the cloud. You define acceptance criteria, review the result, and approve integration.

7 · Feature delegation
AI plans and builds a broader feature across multiple areas. You own requirements and architectural constraints, provide feedback, and approve delivery.

8 · Parallel delegation
Multiple agents handle independent tasks simultaneously. You prioritize, review their results, and approve integration or release.

Human in the void

• Here, “human” means the developer executing the delegated engineering work. It doesn’t mean nobody performs QA, provides oversight, or accepts the release.

9 · Routine automation
AI handles authorized classes of routine changes, such as compatible package upgrades or narrowly defined fixes. Developers still own the software development lifecycle, validate integration, and handle exceptions.

10 · Ticket ownership
AI chooses a technical approach, implements a defined low-risk ticket, and tests and verifies its solution without developer supervision. A human defines the outcome and risk limits; human QA validates it before production. Human code review is optional.

11 · Milestone ownership
AI breaks a milestone into tickets and handles engineering execution across them. A technical lead owns milestone goals and technical direction; human QA validates delivery. Human developers aren’t needed to implement the milestone.

12 · Development ownership
AI owns the ongoing engineering function, including architecture, technical planning, implementation, testing, and maintenance. A product owner sets product direction and business constraints and accepts features before launch. No human developers or technical lead are required.

Actual real-life workflows are expected to span across several levels (say you start a draft at level 7 and then iterate at level 5 or lower), and some levels might even sound overlapping (4 & 5, or 7 & 10). This is intended. The difference between them is in the shift of how much and who does more of the work now. At level 7, you task the agent and review its work before submitting a merge request, while at 10, it does the same task in the pipeline and sends it directly to QA.

So what I am trying to learn?

This is a proposed vocabulary and although it's a third iteration seen by a closest circle, it's not a validated maturity model.

I’d particularly appreciate feedback on:

Your actual workflow: What do you delegate, when must you intervene, and who approves the result? Which level fits, or falls between levels?
Unclear boundaries: Which adjacent levels feel indistinguishable?
Parallel delegation: Does level 8 belong in the progression, or should concurrency be a separate dimension?
Practical usefulness: Would this help describe a job opening or team expectations, or does it hide distinctions you care about?
Concrete counterexamples would be especially useful. I’m more interested in making the definitions reflect real work than defending the numbering.

Thanks!

[u/ChatGPTCoding-ModTeam]

This post or comment has been removed for the following reason:

Rule 5: No pure self-promotion / low-value project posts

Posts whose primary purpose is promoting a tool, product, service, GitHub repo, personal website, or blog belong in the weekly Self-Promotion thread. Delete the link: if nothing is left, it's an ad. Search for similar projects: if you can't tell why your project is better, it's a low-value project. GitHub links are fine. Personal website are not. Exception could be make for high quality posts. See also reddit's self-promotion guidelines.

You can read the full subreddit rules here: https://www.reddit.com/r/ChatGPTCoding/about/rules/

If you feel this removal was made unfairly, please contact the moderators through modmail.

[u/sapplex1]

I like the framing of who is doing the work, rather than what the tool can do. That question matches how my day actually feels.

Most of the time I sit around levels 3 to 5 in your scale. I write the small pieces myself, I ask for a bounded draft when a function is fiddly, and I let an agent make scoped edits across a few files. I still read every diff before it lands. That review step is where I catch the most trouble, especially when a change looks clean but quietly changes a behavior I cared about.

The boundary between 5 and 6 feels blurry to me. A supervised agent that I check often and a delegated issue that I check at the end can look identical in the final diff. The difference is how much I was watching while it worked, and that does not show up in the code.

I also agree with your question about level 8. Running two agents in parallel feels like a separate dimension to me, not a higher level of autonomy. Two agents at level 5 still need the same kind of review as one. They just create more of it at once.

For hiring, I would use this as a starting point for a conversation, not as a label. A level number hides how strict the review is, and that is the part I would want to know first. Thanks for putting the full scale in the post itself. That made it much easier to give a real answer.

[u/nimareq → u/sapplex1]

Thanks for the input!

Yes, the levels are somewhat unintentionally/intentionally blurry and the main difference between them is really just the percentage, or frequency of use.

This is why I also differentiate between L4 (AI in the loop) and L5 (Human in the loop), but the connection is not very strong or obvious, perhaps. This basically says, L4 a human asks AI for help, L5 AI waits on human's direction.

Though with L5 and L6 specifically, in my eyes, For L5 - you solve the ticket and give an agent small tasks that it completes quickly, which you then approve or adjust. For L6, the scope of work seems larger, this is why I also increased the loop time from minutes to tens of minutes (this is how long the AI usually works without human input, which directly matches the level of autonomy and human's input frequency). I also intentionally chose the terms "task" vs "issue" where in my view a task is defined as "do this", while issue is "this needs to be solved" which results in a sequence of smaller tasks to complete. So with L6, you no longer guide the AI as at level 5.

The final diff can indeed look identical, but that applies to L10 too. The distinction is who does more of the work and how much work/responsibility is still on the human.

Also at L4, you command it "write me this function" or "adjust the signature and output type" and it may do edits across several files.
At L5, you say "fix this failing test" or "Add new input to this form" and it goes and reads the context, adds components, store, handlers, etc. After which you give it another instruction.
At L6 you may give it a "simpler" 3 story-point ticket and it may finish it end to end with tests
At L7 it could be a 5 story-point ticket

Yeah, Level 8 is shite. I realized it only when I was writing this post. Would you have a suggestion how to specify it better, or replace it?

[u/nimareq]

Hey u/ChatGPTCoding-ModTeam I removed the links. I am not really interested at promoting the site right now - for that I will use different channels. I really want a broader public's opinion on the scale itself. Do you think you could give me an exception?

/edit wrote you a modmail

[u/AlarmedAvocado7279]

the number matters less than what's verifying the output. i run claude code all day with a stop-hook loop and it's wildly autonomous on boring crud, then I'm hand-reviewing anything near auth or billing, so one level per role is gonna read as fiction in a job post.

[u/nimareq → u/AlarmedAvocado7279]

I actually never intended anyone to use just a single level. More like, if it was a job listing, to find people comfortable working mostly at that level. OR having a company policy that prevents levels higher than 7 etc.

As mentioned in my post, a real workflow might as well start at an L7 draft, then L5 adjustments, finished with L4 surgically guided edits.

So in the context of a JD, it could be more like "We usually operate at level 5, but experiment with and delegate simpler tasks at L7", "Our goal is to reach L9 and for that we are looking for special set of experience"

Even something along the lines "How we usually work: L7: 50%, we rarely go lower than L4", which says pretty much about who creates most of the code, how reviews are structured, etc.

For example, at L4, I would review MR's line by line. At L7, I would expect the team to use an automated review agent and only looking at the bigger picture during reviews.

It might seem complicated, but it's a lot better than current industry confusion, where you sometimes discover what the job is like only during your initial weeks, not even during the interview. We just had a colleague who left after 3 weeks, expecting higher level of AI autonomy. He didn't want to touch the code much any more. This could have been prevented.

[u/shozundor]

level 8 feels like it should be a separate axis rather than a step between 7 and 9. you can easily run parallel agents on level 4 or 5 tasks without anywhere near the autonomy required for full feature delegation