简体中文
English
Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is Recent Thoughts – Thinking in Systems?
Recent Thoughts – Thinking in Systems is a personal blog on nirvacana.com where the author works through systems thinking and its applications to technology and career development. It is a place for long-form essays and mental models rather than news, product reviews or tutorials. Recent Thoughts – Thinking in Systems
The visible posts show two recurring threads:
- AI and agentic systems. “The AI Agentic Systems Ladder” uses the board game Snakes & Ladders — and its origins in Moksha Patam, where ladders were virtues and snakes were vices — as a way to frame stages of AI agent capability. This is conceptual framing, not a vendor comparison or implementation guide.
- Data science careers. “Becoming a Data Scientist – Curriculum via Metromap” maps a learning path as a metro map, and “Demystifying Artificial Intelligence” explains AI from several dimensions. These are aimed at people planning a career or trying to build intuition about a broad field.
Who it suits. Readers who like essays that connect an old idea to a current technology problem, or who want a structured way to think about learning data science, will get the most from it. If you need current tool benchmarks, code walkthroughs or buying advice, this is not the format.
A practical next step. Pick the post closest to your situation — the agentic ladder if you are evaluating AI agents, the metromap if you are planning study — and read it as an argument to test against your own work. Ask what stage your project is actually at, or which part of the curriculum you have skipped, rather than treating either model as a checklist.
How can the AI Agentic Systems Ladder help me evaluate or design agentic AI systems?
The AI Agentic Systems Ladder is a framework on Recent Thoughts – Thinking in Systems for placing agentic AI systems on a maturity spectrum, using the Snakes & Ladders metaphor: ladders are capabilities that raise a system toward autonomy, snakes are failure modes that drag it back. Read it as a diagnostic and design aid, not a product spec.
How to use it for evaluation
- Locate your current system on the ladder before comparing vendors or architectures. The level matters more than the feature list.
- For each rung, name the specific capability that justifies the position — tool use, memory, planning, self-correction, multi-step delegation.
- Then name the snake: the realistic failure that would drop the system a rung. Hallucinated tool calls, unbounded loops, context loss, silent errors that propagate.
- A system that climbs two rungs but has no guard against the snake at rung three is riskier than a system that stays one rung lower with a stable base.
How to use it for design
Treat each rung as a design decision with a cost, not a target to reach. Higher autonomy typically means more orchestration, more observability and harder debugging. Decide deliberately where to stop.
| Question | Lower rung | Higher rung |
|---|---|---|
| Who decides the next step? | You, per prompt | The system, per goal |
| Failure visibility | Immediate, obvious | Delayed, may look like success |
| Debugging effort | Low | High — needs tracing |
| Best fit | Narrow, high-stakes tasks | Repetitive, well-instrumented workflows |
A concrete scenario
A support team wants an agent that resolves tickets end to end. Before building, map it: retrieval plus drafting sits low; autonomous refunds and account changes sit much higher. The pragmatic path is to climb one rung at a time — draft, then suggest actions, then execute with approval, then execute with audit — and only proceed when the snake at the current rung is contained.
Next step
Write your system's current rung, the evidence for it, and the single snake most likely to pull it down. If you cannot name the snake, you have not yet earned the next rung.
What does the Snakes & Ladders analogy reveal about progressing through AI agentic system levels?
The analogy frames progress as non-linear: you climb through capability levels, but design or operational failures can drop you back. The site's post "The AI Agentic Systems Ladder" uses the board game's origins—ladders as virtues, snakes as vices—to suggest that advancing in agentic AI depends as much on avoiding failure modes as on adding capability. Read it at Recent Thoughts – Thinking in Systems.
What the analogy implies in practice
- Levels are cumulative, not just sequential. A higher rung usually assumes the reliability of lower ones; skipping a rung often means inheriting hidden weaknesses.
- Snakes are recurring risks, not one-time setbacks. Common examples include over-trusting autonomous actions, weak evaluation, unclear handoffs, and poor observability. Each can undo a level's gains.
- Virtues are the stabilizers. Guardrails, human review, testing, and clear scope act like ladders—they don't replace capability, but they make climbing stick.
A concrete reader scenario
A team ships an agent that drafts customer replies. It performs well in demos, so they grant it direct send permissions. A misread refund request goes out; trust drops and the team reverts to manual review. In the analogy, the capability climb was real, but the missing guardrail was a snake that sent them back a level.
Next step
Before moving up a level, list the failure modes that would force a rollback, then decide which guardrails must exist first. If you can't name the snakes, you're not ready for the next ladder.
What is artificial intelligence explained from different dimensions?
The site frames AI as something to be understood from several angles rather than a single definition. Its post "Demystifying Artificial Intelligence" sets out to explain AI "from different dimensions," and the surrounding writing shows what those dimensions look like in practice: an agentic-systems ladder that ranks how independently a system can act, and a data-science learning path mapped like a metro network.
The dimensions worth separating
| Dimension | The question it answers | Why it changes your view |
|---|---|---|
| Capability | What can the system actually do? | Separates narrow task tools from general reasoning |
| Agency | How much does it decide and act on its own? | A chatbot that suggests differs from an agent that executes |
| Data and learning | Where does its knowledge come from? | Trained-once models behave differently from systems that keep learning |
| Human role | Who stays in the loop? | Determines oversight, review and accountability |
| Impact | What changes for work and society? | Shifts the debate from technique to consequences |
The agentic ladder is the most concrete of these. It treats autonomy as a scale: a system that drafts text sits low; one that plans steps, calls tools and completes a task with little supervision sits high. Reading AI this way is more useful than asking whether something "is AI," because the same underlying technology can sit at different rungs depending on how it is wired up.
For a practical next step, take one AI tool you already use and place it on each row above. If you cannot say where the human check sits, that is the gap to close before trusting it with more.
How can I use the Metromap curriculum to plan a path toward becoming a data scientist?
The Metromap is best treated as a sequencing guide, not a course list. Its value is showing how the pieces of data science connect—statistics, programming, machine learning, data engineering, communication—so you can decide what to learn next instead of collecting random tutorials. The site frames becoming a data scientist as a multi-year journey rather than an overnight switch, which is the right expectation to set.
A practical way to work through it
- Self-assess against each station. For every topic on the map, mark yourself as "can explain it," "can use it with reference," or "can build with it." The gaps become your plan.
- Order by dependency, not by appeal. Linear algebra and probability before machine learning; Python or R and SQL before either; data cleaning and visualization before modeling. Skipping prerequisites is the most common way people stall.
- Attach one artifact to each stage. A cleaned dataset, a regression write-up, a small classifier with an honest evaluation, a dashboard. Portfolio evidence beats course certificates.
- Revisit the map every few months. Progress is easier to see against fixed stations than against an endless feed of new tools.
Trade-offs to weigh
| Approach | Strength | Weakness |
|---|---|---|
| Follow the Metromap top to bottom | Coherent, no gaps | Slow; can feel academic |
| Jump straight to machine learning | Fast motivation | Fragile foundations, hard to debug models |
| Project-first, fill gaps as needed | Fast feedback, portfolio grows | Risk of blind spots you never notice |
For most career changers, a hybrid works best: pick a project, then use the Metromap to identify which missing station is blocking you.
A concrete scenario. Suppose you have spreadsheet skills and basic Python. Your first month: SQL joins and aggregation, plus pandas cleaning on a messy public dataset. Second month: descriptive statistics and visualization, ending with a written analysis of what the data does and does not support. Third month: one supervised model with proper train/test splits, and a short note on why you chose it. At each point, check the map to confirm you are not about to build on something you skipped.
Decision criterion for what to learn next. Choose the topic that unblocks your current project and that you can practice on real data within a week. If a station cannot be practiced soon, defer it.
For a broader view of the underlying disciplines, the curriculum ideas at Kaggle and the open course material at MIT OpenCourseWare pair well with the map's structure.
What should I consider when transitioning into a data science career based on this blog's guidance?
The blog is most useful as a mental model and curriculum map, not as a step-by-step job plan. Its central guidance appears in "Becoming a Data Scientist – Curriculum via Metromap" (2013), which frames data science as a journey rather than something you can pick up overnight, and in "Demystifying Artificial Intelligence" (2017), which explains AI from several dimensions instead of treating it as one skill.
That means the main things to weigh are:
- Breadth vs. depth. The metromap approach implies you need a connected set of areas—statistics, programming, machine learning, data handling—rather than one narrow tool. Decide early which area you want to go deep in, because the map shows the terrain, not the order to conquer it.
- Foundations before tools. The 2017 AI post's "different dimensions" framing suggests understanding what AI is and where it fits, not just memorizing libraries. Tool knowledge dates quickly; conceptual understanding travels.
- Sequence and patience. The 2013 post explicitly warns against expecting overnight results. Plan for months of steady work, with visible milestones, rather than a single course or certificate.
- Your starting point. A software developer, a statistician and an analyst will each enter the map at a different place. The blog's value is showing how the pieces connect, so you can identify your own gaps.
- The map is old. A 2013 curriculum and a 2017 AI explainer predate much of today's tooling and hiring expectations. Use them for structure and concepts, then verify current requirements separately.
- Portfolio over credentials. Nothing in the page evidence points to certification or pricing as the route in; the emphasis is on guided self-study. Build small projects that demonstrate each area you claim.
A practical next step: sketch your own version of the metromap with three columns—what you already know, what you can learn in the next three months, and what needs a year. Then pick one project that forces two columns to meet, such as a small end-to-end analysis with a written explanation of your choices.
For current, structured curricula, compare with Coursera or MIT OpenCourseWare. For community discussion of how people actually sequence these skills, Kaggle is a reasonable place to look.
User reviews (0)