As I read the list, I noticed they were severely out of order, with unconvincing excuses for why one thing led to the next and poorly placed this-is-where-s###-gets-real moments like "You begin to understand." :-p But that's fine. The list is probably a valid reflection of the author's own experience with programmers, and I doubt it stereotypes programmers in any harmful way.
What follows is an autobiography by counterexample. That is, it's my anecdotal evidence for the original order being out of whack.
For a high-level view (or for the sake of tl;dr), my progression is 1-8-M-4-5-7-2-10-7-9-9-3-9-M-6-5-9, and I consider my progress to be incomplete in levels 2, 8, 10, and M.
Level 1, The Read-and-Type
Level 8, Meta Man (In the sense that I approached every problem by designing a new language, not in the sense that I actually implemented easy-to-use languages and tools! I'm still working on that, lol.)
Mystery Level, Computer Scientist (in the sense that I hoped my pseudocode languages were advancing the state of the art, though they really weren't)
Level 4, Object-Dot-Method Guy
Level 5, Multiple Paradigm Man (in the sense that I knew that I could get certain things easily from one language that were more difficult or impossible in another)
Level 7, Architect Astronaut (not because I confused complexity with value, but because I was finally able to shoehorn abstract concepts into existing languages rather than keeping them in pseudocode)
Level 2, The Script Kiddie (in the sense that I started using filesystem calls sometimes but not on a whim)
Level 10, Language Oriented Designer (in the sense that I decided it would always be true that with certain shoehorned pseudocode, it makes life easier to admit it's a language of its own)
Level 7, Architect Astronaut (in the sense that my languages would have had kitchen sinks at this point in my life)
Level 9, Functional Nirvana (but only in the sense that I knew I'd learn a lot about custom syntax from a lisp)
Level 9, Functional Nirvana (in the sense that as I approached lisp--by way of Groovy--I discovered the sweetness of using first-class procedures for list comprehension, custom control flow, event handlers, etc.)
Level 3, The Librarian
Level 9, Functional Nirvana (in the sense that I actually started using a lisp, Arc)
Mystery Level, Computer Scientist (in the sense that I realized the language-oriented technique I wanted to pursue was not available in any language, and I expected to need to advance the state of the art)
Level 6, Architect Apprentice (Thanks to my frustration at the places Arc's modularity, customizability, and extensibility falls short (especially its modularity), and the fact that there was no other language I liked better, I've focused on Arc library design in particular and learned what approaches I liked and what approaches I could expect even if I didn't like 'em.)
Level 5, Multiple Paradigm Man (in the sense that every way to improve on Arc's code reusability seemed to require a compromise)
Level 9, Functional Nirvana (in the sense that I've realized that expressing certain kinds of modularity takes a reactive model and/or a static type system, and that an understanding of pure FP does me wonders for elucidating the semantics of both of these things)
For humility's sake, here's a list (a checklist?) of the levels I know I haven't fully explored:
Level 2, The Script Kiddie (in the sense of not being shy to write a program to automate a mundane task)
Level 8, Meta Man (in the sense of implementing easy-to-use languages and tools)
Level 10, Language Oriented Designer (in the sense of implementing easy-to-use tools for myself and others to make languages with)
Mystery Level, Computer Scientist (in the sense of framing my work in academic terms)
Hey, that is comprehensive. And I do agree that the levels in the article reflect the author's own experience, which he also admits. Like yours, most people would follow paths different from the progression in the article, though I don't think most would document it quite as thoroughly!
I notice that the levels don't include the kind of programming I used to do ten years or so ago. Back then I was doing low-level assembly language programming for 8-bit microcontrollers on embedded systems. The sort of programming where hardware knowledge is as important as software. Programming down to the bare metal is the colorful phrase for it I think.
Mostly I'm at levels 4, 5, 8 (Ruby finds you doing a lot of metaprogramming), and occasionally 9 (well, there is Arc and I sometimes do Ocaml and Erlang). I once had a glimpse of the mystery level which I suppose is inhabited by folks like Donald Knuth and Gregory Chaitin, but I had to drop my Master's in Computer Science when real work came calling.
I had a hard time figuring out where I would fit in simply because I started with FP which starts at Level 9. And as for Level 10... well even though I have an interest in language design I really have no interest in designing a language (I like reading your guys's stuff, but I don't think I would want to do that myself).
So I suggest all programmers start at level 9 by starting in ARC. :)
I found this to be quite interesting, and figure many of the folks here, if not most, are probably at Level 10. With a little bit of exaggeration I'm probably a Multiple Paradigm Man, at a lowly Level 5.