OPEN MIND · INQUIRY · ENGINEERING · XXI → 0
There has never been so much AI within a developer's reach—and perhaps never so much uncertainty about where to begin.
One day we are discovering autocomplete. Soon we are debating prompts, vibe coding, context windows, agentic workflows, MCP, Skills, AI-driven delivery, and AI-native systems. Every week offers another tool, another framework, another claim that everything has changed.
What does a developer actually need to learn? And more importantly, what is changing in the way we understand and build software?
The journey is not about mastering AI. It is about transforming understanding.
Contents
- A map, not a maturity ladder
- Three paths through the journey
- Act I — The Awakening
- Act II — The Turning Point
- Act III — Integration and Return
- The 22 Major Arcana as three interwoven paths
- A practical engineering example
- Where are you in the journey?
- XXI → 0: the return
- The Journey as a Semantic Model
- References and further reading
A map, not a maturity ladder
The Fool’s Journey, a popular narrative interpretation of the 22 Major Arcana, gives us an intriguing metaphor. The Fool (0) represents openness: the willingness to step forward without possessing every answer. The World (XXI) represents integration: seeing connections that were invisible at the beginning. But the story does not end there. XXI returns to 0. Experience changes the traveler; uncertainty remains.
This is a literary and educational metaphor, not a claim that tarot predicts technological progress. Nor is it a prescription that every developer must encounter every tool in the same order. Different capabilities overlap; they are not badges on a universal career ladder.
Instead of asking “Which tool comes after prompts?”, ask “What problem am I trying to understand, and what capability would help me investigate it responsibly?”
Major Arcana imagery: Rider–Waite–Smith (Pam-A) collection, illustrated by Pamela Colman Smith (1909–1910), via Wikimedia Commons. Original artwork is public domain; card images load from Wikimedia Commons and require an internet connection unless downloaded locally.
Three paths through the journey
The Secret of the Sphinx explores a symbolic reading of three paths: Osiris, Thoth–Sopdet, and Horus. We can borrow that interpretive lens for software engineering without suggesting that it is an established historical taxonomy of tarot or a mandated order of technological progress.
These are three interwoven paths with specific Arcana sequences, not three compulsory levels. Transformation challenges assumptions; awakening deepens observation and understanding; experience tests understanding through action. Their symbolic lessons can overlap in practice, but the card sequences shown below retain their defined order.
Osiris · Transformation
What must I reconsider or leave behind?
From the assumption that productivity means typing code, to questioning premature trust, obsolete habits, and fragile automation.
Developer practice: review assumptions, recognize failure modes, and redesign the process.
Thoth–Sopdet · Awakening
What am I beginning to understand?
Prompts, context, tools, MCP, agents, and Skills expand what can be explored—but do not automatically establish what is true.
Developer practice: investigate, ask better questions, and make uncertainty explicit.
Horus · Experience
How can I apply and validate what I understand?
Turn hypotheses into bounded workflows, useful software, tests, reviews, evaluations, and accountable AI-native design.
Developer practice: build, measure, verify, and learn from consequences.
Three paths, one evolving understanding. Transformation changes our assumptions. Awakening changes what we notice. Experience tests what we build. None of them removes the need for the others.
The arcana remain the symbolic encounters of the story; these paths describe different ways to interpret what happens during those encounters. For example, the Hanged Man (XII) belongs to the Path of Horus, the Tower (XVI) to the Path of Osiris, and Justice (XI) to the Path of Thoth–Sopdet. These correspondences are editorial interpretations rather than fixed tarot rules.
Explore the 22 Major Arcana
Choose a card without leaving this view. The reading below continues in three expandable acts.
The Fool
- Context
- Open-minded AI exploration
- Light
- Curiosity and experimentation
- Shadow
- Naivety and blind trust
- Insight
- Explore without surrendering judgment
Act I — The Awakening
Explore Arcana 0–IVOpen mind, code completion, prompts, creativity and workflows
The Fool — An open mind
Imagine a developer in a familiar environment: editor, terminal, tests, pull requests, deadlines. A new assistant appears in the IDE. Curiosity competes with skepticism: Will this help? Will I lose my skills? Should I trust it?
An open mind is not unconditional enthusiasm. It is the willingness to experiment without surrendering judgment. The first change is not in the stack; it is in the posture toward the unknown.
The Magician — Code completion
An intelligently suggested line, a function, a test scaffold: the developer still chooses the direction, while AI reduces friction at the keyboard.
The small convenience raises a much larger question: If AI can complete code, what else could it help me do?
The High Priestess — Prompts and context
Conversation expands beyond completion: explain an unfamiliar Rails service, surface trade-offs, compare approaches, or challenge an assumption.
Strong prompting depends on context, constraints, examples, and iterative inquiry—not magical wording or presumed correctness.
The Empress — Vibe coding and creation
Natural-language generation accelerates prototypes. An idea becomes an interface or small product quickly enough to discover what the developer actually wants.
But vibe coding, especially without serious code inspection, is not the same as production-grade engineering. Demonstrating possibility is not proving reliability.
The Emperor — Workflows and structure
Instead of collecting disconnected answers, turn work into a reproducible sequence: research, design, implement, test, review, publish. Make inputs, checks, and outputs explicit.
The emphasis shifts from one useful answer to a dependable way of working.
“Refactor this job.”
“Identify failure modes in this Sidekiq job, preserve idempotency, propose alternatives, and show which assumptions require tests.”
Act II — The Turning Point
Explore Arcana V–XVISkills, tools, agency, verification, perspective and risks
The Hierophant — Skills and tradition
Expertise can be captured in reusable Skills: procedures, project conventions, examples, review criteria, and domain knowledge.
The question changes from What should I prompt? to Which practice can my team repeat and inspect?
The Lovers — Human–AI collaboration
AI can propose and execute. The developer still frames intent, defines boundaries, evaluates trade-offs, and accepts responsibility.
Good collaboration is neither total delegation nor refusal to delegate; it is a deliberate division of work.
The Chariot — Tools and MCP
Tools expose concrete actions; MCP provides a protocol for connecting approved capabilities and context. An assistant can reach repositories, APIs, documentation, and tests.
Access expands what can be done, but permissions and provenance must remain explicit.
Strength — Controlled autonomy
Agents can plan and perform multistep work, including editing files, running checks, and proposing a pull request.
Controlled autonomy requires bounded goals, permissions, traceability, checkpoints, and human approval where warranted.
The Hermit — Reflection and discernment
When a result looks convincing, the developer must still ask: How do I know?
Reflection means examining assumptions, reading the code, reviewing generated explanations, and seeking evidence beyond fluent output.
Wheel of Fortune — A changing landscape
Models, products, and workflows evolve. What works today may change with the next release or context window.
Keep the engineering principles portable: explicit requirements, reproducible tests, observability, and the ability to recover safely.
Justice — Verification and accountability
A passing test does not necessarily prove the right behavior was tested. A link does not automatically supply evidence. A successful tool call is not a validated business outcome.
Verification joins correctness, security, provenance, and accountable review. Capability is not correctness.
The Hanged Man — A change in perspective
This is the turning point: producing more code faster is not the same as knowing what should be built, why, and how to determine whether it fulfills the intent.
Code becomes an expression of understanding, never its substitute.
Death — Letting go of assumptions
Some assumptions must be released: that professional value is measured by lines typed, that every task needs an agent, or that a demo proves readiness.
Leaving those assumptions behind makes more room for domain understanding and sound engineering choices.
Temperance — Human–AI integration
Balance automation with tests, architecture, observability, human communication, and operational constraints.
The goal is not to choose human or machine, but to design a process in which each contributes what can be justified and verified.
The Devil — The dependency trap
Convenience can become dependence: unfamiliar code is accepted, investigation is skipped, and authority is delegated without safeguards.
The danger is less the presence of AI than the disappearance of independent judgment.
The Tower — Failure reveals the architecture
Reality intervenes: a payment job retries twice, a data migration violates invariants, or an agent changes the wrong files.
Failure asks a sharper question: What did our process fail to understand?
AI can generate options. Engineering judgment evaluates constraints, evidence, risks, and consequences.
Act III — Integration and Return
Explore Arcana XVII–XXINew perspectives, uncertainty, clarity and AI-native integration
The Star — Renewed vision
A renewed engineering vision sees relationships among people, knowledge, tools, models, policies, and evaluations.
We can pursue better outcomes rather than simply more generated output.
The Moon — Uncertainty and evidence
Models generate claims; systems retrieve sources; neither operation proves understanding. Uncertainty must be represented rather than concealed.
Distinguish output, source, evidence, claim, and understanding, and keep unresolved questions visible.
The Sun — Clarity through inquiry
Clarity grows when intent is explicit and observations can be tested against expectations.
The objective is not certainty about everything. It is an honest, revisable account of what the system does and why.
Judgement — Reimagining architecture
The architectural question emerges: when should AI participate in a running product rather than only in the development workflow?
Think about model inference, tools, context, evaluation, governed actions, and feedback as designed capabilities—not magic defaults.
The World — Integration, not completion
A wider picture comes into view. Prompts, Skills, agents, workflows, and models become design choices in service of people and real constraints.
The World is integration, not final mastery. From XXI the developer returns to 0—with fresh questions and a wider perspective.
AI-Assisted
AI helps developers build.
Example: GitHub Copilot suggests Rails code, explains a service, or drafts a test for human review.
AI-Driven
AI drives bounded parts of the process.
Example: An agent proposes a change, runs tests, and prepares a pull request for human approval.
AI-Native
AI participates in the running system.
Example: A product integrates model inference, tools, context, evaluation, and governed actions.
These are working distinctions, not an official certification ladder. An AI-native product can still be developed with traditional tooling; an AI-assisted team can ship entirely deterministic software.
The 22 Major Arcana as three interwoven paths
The card associations below are interpretive, not technological milestones. Begin with 0 — The Fool above, then expand any of the three paths to explore its seven-card sequence as illustrated cards with engineering context. The final card, XXI — The World, returns to 0. We use the common Rider–Waite–Smith numbering, where Strength is VIII and Justice is XI.
Card artwork: Pamela Colman Smith, Rider–Waite–Smith tarot (1909). Public-domain originals. Images are currently served from an external archive; use the included download script to self-host them before publishing.
Follow each path in its own order: Osiris · Thoth–Sopdet · Horus. The cards are deliberately interwoven, not consecutive phases.
The Path of Osiris — TransformationI → IV → VII → X → XIII → XVI → XIXWhat must I reconsider or leave behind?
The Magician
AI-Assisted / Code CompletionDiscovering the capability to turn intent into code
The Emperor
Structured WorkflowsGiving experimentation repeatable structure and constraints
The Chariot
Tools and MCPConnecting tools, APIs and repositories with direction
Wheel of Fortune
Technology ChangeAdapting to shifting models and capabilities
Death
Letting GoRevising assumptions about what developer value means
The Tower
Failure and RealityFacing architectural limits and failed assumptions
The Sun
ClarityMaking intent, architecture and consequences more visible
The Path of Thoth–Sopdet — AwakeningII → V → VIII → XI → XIV → XVII → XXWhat am I beginning to understand?
The High Priestess
Prompts and ContextLooking beneath answers; asking better questions
The Hierophant
Knowledge and SkillsEncoding shared knowledge into reusable practice
Strength
Controlled AutonomyExercising restraint and oversight with agents
Justice
Verification and AccountabilityTesting claims, risks, correctness and consequences
Temperance
IntegrationBalancing craft, automation and judgment
The Star
Renewed VisionImagining better engineering outcomes
Judgement
AI-Native ReorientationRethinking software architecture around AI capabilities
The Path of Horus — ExperienceIII → VI → IX → XII → XV → XVIII → XXIHow can I apply and validate what I understand?
The Empress
Vibe Coding / CreationRapid prototyping and creative exploration
The Lovers
Human–AI CollaborationChoosing what to delegate and what to decide
The Hermit
ReflectionQuestioning outputs and seeking real understanding
The Hanged Man
Perspective ShiftMoving from code output to problem understanding
The Devil
Dependency TrapRecognizing overreliance and false productivity
The Moon
UncertaintySeparating model output, claims, evidence and understanding
The World
Integrated EngineeringConnecting the whole and returning to renewed inquiry
A practical engineering example
Suppose you are asked to improve the reliability of payment processing in a Rails application.
An autocomplete-only approach helps write another retry method. A prompt-first approach asks for recommendations. A workflow-driven approach inspects the code, develops a failure model, implements changes, runs checks, and requires review. With tools and agents, much of that work can be coordinated across repository, CI, and documentation. With Skills, project-specific conventions can become repeatable.
But none of those capabilities can replace the critical questions: Is the operation idempotent? What happens under duplicate delivery? Which side effects can be reversed? Which invariant proves business correctness? Who approves the change?
“The AI wrote a retry policy.”
“We identified the failure modes, tested the invariants, and can explain why the recovery policy is appropriate.”
The deepest gain is not the number of generated lines. It is the ability to discover, test, and preserve a more accurate account of the system.
Where are you in the journey?
Do not measure your progress by how many new products you have installed. Ask which questions you can now answer:
- Exploring? Can you explain what you want AI to help you discover?
- Prompting? Can you supply context, constraints, and verification criteria?
- Automating? Can your workflow fail visibly and recover safely?
- Connecting tools? Can you describe what the system is permitted to access and change?
- Delegating to agents? Can you tell the difference between execution success and task correctness?
- Designing AI-native systems? Can you represent uncertainty, audit decisions, and evaluate outcomes?
Find your current question. Choose the smallest capability that helps answer it. Verify what you learned. Repeat.
The World
Integrated EngineeringConnecting the whole and returning to renewed inquiry
The Fool
Open MindCuriosity and willingness to explore the unknown
A New Understanding. A New Beginning.
XXI → 0: the return
The Fool begins without knowing. The World arrives with a wider understanding. But wisdom is not the absence of uncertainty. It is the ability to return to uncertainty with better questions, stronger methods, and greater responsibility.
The engineer who first discovered intelligent autocomplete is not quite the same engineer who now considers agent orchestration, Skills, evidence, or AI-native architecture. Yet the most important capability remains recognizable: an open mind prepared to investigate what is actually happening.
Every new tool expands what a developer can do. Every new understanding transforms what a developer can become.
The World is not the end of the journey. It is the moment the Fool discovers a new beginning.
The Journey as a Semantic Model
The twenty-two Arcana can be described once as a set of contextual meanings, then related through three interwoven paths. In this interpretation, Context situates each card in AI engineering, Light expresses its constructive possibility, Shadow explores its limitations, and Insight captures a question or understanding that may emerge. These are interpretive perspectives, not proven properties of the cards or evidence about AI systems.
The Mermaid diagram presents the overall relationships. Expand the Ruby DSL below to explore the full model of the 22 Arcana, their AI contexts, three paths, and the return XXI → 0. This is an illustrative Ruby DSL, not a working parser or executable implementation.
Explore the complete Ruby DSL22 Arcana · Context / Light / Shadow / Insight · Three paths · XXI → 0
Illustrative Ruby DSL for understanding the article’s structure; this example is not an executable implementation.
journey "The Developer's AI Journey" do
inquiry "How does AI transform software engineering?"
# I. Arcana: meaning definitions
arcana 0, "The Fool" do
context "Open-minded AI exploration"
light "Curiosity and experimentation"
shadow "Naivety and blind trust"
insight "Explore without surrendering judgment"
end
arcana 1, "The Magician" do
context "AI code completion"
light "Augmented development"
shadow "Illusion of mastery"
insight "Capability is not understanding"
end
arcana 2, "The High Priestess" do
context "Prompts and context"
light "Deeper inquiry"
shadow "Superficial prompting"
insight "Context changes understanding"
end
arcana 3, "The Empress" do
context "Vibe coding"
light "Creative experimentation"
shadow "Unexamined code generation"
insight "Prototypes are not products"
end
arcana 4, "The Emperor" do
context "Structured AI workflows"
light "Repeatability and control"
shadow "Excessive rigidity"
insight "Structure supports intent"
end
arcana 5, "The Hierophant" do
context "Knowledge and reusable Skills"
light "Codified engineering expertise"
shadow "Dogmatic procedures"
insight "Knowledge must remain revisable"
end
arcana 6, "The Lovers" do
context "Human-AI collaboration"
light "Complementary capabilities"
shadow "Abdication of responsibility"
insight "Delegation requires discernment"
end
arcana 7, "The Chariot" do
context "Tools, MCP and execution"
light "Connected capabilities"
shadow "Uncontrolled execution"
insight "Direction matters more than reach"
end
arcana 8, "Strength" do
context "Agent autonomy and governance"
light "Responsible delegation"
shadow "Excessive autonomy"
insight "Power requires restraint"
end
arcana 9, "The Hermit" do
context "Independent technical inquiry"
light "Reflection and critical thinking"
shadow "Isolation and analysis paralysis"
insight "Question outputs before accepting them"
end
arcana 10, "Wheel of Fortune" do
context "Rapid evolution of AI technologies"
light "Adaptability"
shadow "Trend chasing"
insight "Principles outlast tools"
end
arcana 11, "Justice" do
context "Testing, verification and evaluation"
light "Evidence-based engineering"
shadow "False confidence in passing tests"
insight "Success is not proof of correctness"
end
arcana 12, "The Hanged Man" do
context "Perspective shift"
light "Reframing the problem"
shadow "Mistaking activity for progress"
insight "Understand before building"
end
arcana 13, "Death" do
context "Transformation of developer roles"
light "Renewal and adaptation"
shadow "Fear of obsolescence"
insight "Let go of obsolete assumptions"
end
arcana 14, "Temperance" do
context "Human-AI systems integration"
light "Balanced collaboration"
shadow "Misaligned automation"
insight "Integrate without losing judgment"
end
arcana 15, "The Devil" do
context "Dependency on AI-generated solutions"
light "Awareness of limitations"
shadow "Cognitive dependence"
insight "Convenience must not replace thought"
end
arcana 16, "The Tower" do
context "Failures in AI-assisted systems"
light "Architectural learning"
shadow "Fragile automation"
insight "Failure exposes hidden assumptions"
end
arcana 17, "The Star" do
context "New possibilities for AI engineering"
light "Renewed technological vision"
shadow "Technological idealization"
insight "Vision requires grounded inquiry"
end
arcana 18, "The Moon" do
context "Uncertainty and hallucinations"
light "Epistemic humility"
shadow "False certainty"
insight "Distinguish claims from evidence"
end
arcana 19, "The Sun" do
context "Engineering clarity and observability"
light "Transparency and verification"
shadow "Overconfidence"
insight "Make understanding verifiable"
end
arcana 20, "Judgement" do
context "AI-native architectural reorientation"
light "Intent-centered system design"
shadow "Reinvention without purpose"
insight "Design around meaningful intent"
end
arcana 21, "The World" do
context "Integrated AI-native engineering"
light "Coherent systems thinking"
shadow "Illusion of completion"
insight "The whole remains open to revision"
end
# II. Paths: relationships, without redefining Arcana
origin :the_fool, arcana: 0
path :osiris do
meaning :transformation
traverse 1, 4, 7, 10, 13, 16, 19
question "What must I reconsider?"
end
path :thoth_sopdet do
meaning :awakening
traverse 2, 5, 8, 11, 14, 17, 20
question "What am I beginning to understand?"
end
path :horus do
meaning :experience
traverse 3, 6, 9, 12, 15, 18, 21
question "How can I apply and validate it?"
end
interweave :osiris, :thoth_sopdet, :horus
# III. Evolving understanding and return
understanding :evolving do
consider :light, :shadow, :insight
integrate :experiences, :perspectives
examine :contradictions
preserve :evidence, :provenance, :uncertainty
remain_open_to :revision
end
return from: 21, to: 0 do
carry :evolving_understanding
transform :perspective
renew :inquiry
question "What can now be seen differently?"
end
endThe semantic definitions and the three paths are distinct: the paths reference the Arcana rather than duplicating them. The return preserves evolving understanding without suggesting that uncertainty has disappeared.
The journey does not repeat itself. It unfolds again from a different understanding.
References and further reading
- Model Context Protocol — Introduction — tools, resources, and interoperable connections.
- GitHub Docs — About Agent Skills — reusable agent guidance.
- Anthropic — Equipping Agents for the Real World with Agent Skills — practical skill packaging.
- Martin Fowler — AI — engineering considerations for AI-assisted development.
- DORA Research — evidence on AI and software delivery.
- Andrej Karpathy’s original vibe-coding discussion (February 2025) — historical framing of the term.
- Joseph Campbell, The Hero with a Thousand Faces and Christopher Vogler, The Writer’s Journey — narrative frameworks used only as literary inspiration.
Editorial note: The Fool’s Journey and the associations between the Major Arcana and software engineering are original interpretive metaphors. The article does not present AI-Assisted, AI-Driven, and AI-Native as standardized maturity levels.