AI-Native Engineering Archetype
Tier 1 ★The future is leaking into my workflow, and I'm taking notes.
You're exploring AI tools and forming your own opinions about what actually works. You've tried a few things, seen promising results, and you're building intuition through hands-on experience. Curiosity is your edge. Most engineers haven't even started.
Find out where you stand with AI coding agents
Every great AI-native engineer looked like you at some point. Curious, hands-on, willing to try things before anyone agreed on the right approach. The Experimenter isn't behind. They're early. And when the rules are still being written, early and attentive beats experienced and rigid.
Your day-to-day with AI tools is exploratory. You reach for them when a task feels like a match, you watch what happens, and you file away what you learn. You've probably noticed that some types of work come back surprisingly clean, while others still feel awkward or unreliable. That instinct is worth more than you think. You're building a mental model most of your peers haven't started on.
The Experimenter's biggest strength is that openness. You haven't locked into a workflow designed for a pre-AI era. You don't carry the "I've always done it this way" weight that makes change expensive for more senior engineers. When a better approach shows up, you can just adopt it.
Your growth edge is moving from sampling to systematic. Right now, you use AI tools in moments of inspiration. The next step is making them part of every task by default, including the ones that don't feel like obvious fits. That means delegating things you're unsure about, watching how they fail, and learning the boundary between what agents handle well and what still needs you.
The other shift worth starting is structured delegation. Write a short PRD for every feature before handing it to an agent: what it does, what files it touches, what "done" looks like. That document becomes context the agent works from instead of guessing. The engineers at higher tiers go further: hierarchical context files across the codebase, custom linting rules with error messages that act as instructions for agents, meta-prompting frameworks that break work into fresh-context phases so agents never degrade from context rot. You're building toward all of that. It starts with the habit of writing the spec before the prompt.
Every orchestrator running five parallel streams and shipping ten times what their peers ship started right here. The difference is reps. And you're getting yours.
You've started picking up AI coding tools and you're learning what they can do. You reach for them when the problem feels right, and your instincts are getting sharper. The next step is making that reach automatic.
You work mostly off the cuff, prompting from memory rather than from structured agent instructions. The engineers above you on this spectrum maintain hierarchical context files, write custom linting rules that act as guardrails for agents, use meta-prompting frameworks that keep context rot at bay. Those techniques are closer than they sound. Understanding what agents can do is the hard part, and you're already doing that.
Most of your code still flows through your own hands, with agents helping at the edges. You're figuring out what's safe to hand off and what still needs your direct attention. That confidence grows with reps, and you're getting them.
You run one thing at a time, one session at a time. That makes sense. Parallelism pays off once you can reliably delegate, and right now the priority is getting one agent session to deliver before spinning up more.
Your workflow looks largely the same as it did before AI tools. That tracks. Process change tends to follow skill change, and you're still building the skills. As those develop, the workflow will shift to match.
The Five Levels of Agentic Engineering
“The future is leaking into my workflow, and I'm taking notes.”
You're exploring AI tools and forming your own opinions about what actually works. You've tried a few things, seen promising results, and you're building intuition through hands-on experience. Curiosity is your edge. Most engineers haven't even started.
How to level up
The gap between experimenting and practicing is consistency. Right now you reach for AI tools when something feels like a good fit. The Practitioner has killed that hesitation. AI is just how they work, not a special mode they switch into.
To get there, build one habit at a time. Start delegating a full feature draft on every task, even when you think you'd be faster doing it yourself. Write a short PRD before you hand anything off: what the feature does, what files it touches, what the acceptance criteria are. Pay attention to where the agent goes wrong, because those failure patterns tell you exactly what to put into your context files, linting rules, and test suites.
The Practitioner doesn't know more than you. They've just practiced longer.
How AI-native is your engineering workflow?
Find out where you stand with AI coding agents.
Take the Assessment