Computational Thinking & AI Mastery – Detailed Session Notes

Session Overview

  • Live AI Mastery class led by Vykintas Glodenis (Vic) on “Computational Thinking – stacking the building blocks”.

  • Aim: To provide participants with essential mental models and practical frameworks, enabling them to transform complex AI and automation ideas into manageable, testable, and actionable solutions.

  • The session deliberately did not rely on traditional slides. Instead, a comprehensive Airtable base (link shared during the call) was provided to all participants. This base served as a dynamic, interactive resource, containing:

    • Pre-built frameworks and templates, offering immediate starting points for various AI/automation challenges.

    • Extension demos, illustrating practical applications and enhanced capabilities of different tools within Airtable.

    • Dedicated sections for learners to copy and customize these resources, fostering hands-on application and personalized learning experiences.

  • Key insight: Even with the increasing power and sophistication of modern AI models, the ultimate success of any project profoundly depends on the clarity of human mindset, critical thinking, and rigorous, systematic patterns of thought.

Stage 0 – Strategy (WHY before HOW)

  • The reason for adding a “Stage 0” before the classical computational-thinking steps is crucial: many projects fail not due to technical limitations, but because the wrong problem is being solved or an inefficient approach is chosen from the outset.

  • Two core frameworks were introduced to address this foundational stage:

    • To – When – So (2 & So):

    • This is a concise sentence template designed to force clarity and strategic alignment: “We want to TO (action) WHEN (trigger/event) SO we can (objective).”

    • It compels teams to explicitly define: the specific action to be taken, the precise trigger or event that initiates the action, and the clear, measurable objective or value derived from the action.

    • Learners actively filled this template live in Airtable during the session. Vic emphasized the importance of appending concrete Key Performance Indicators (KPIs) or Key Results (KRs) to the objective (e.g., “reduce time-to-market from 12 \rightarrow 7 days”).

    • MVP \perp OODA loop:

    • This framework combines the Minimum Viable Product (MVP) concept with Colonel John Boyd’s OODA loop (Observe \rightarrow Orient \rightarrow Decide \rightarrow Act, which is a continuous cycle).

    • The integration encourages releasing a minimum viable product early to iterate rapidly based on real-world data and feedback.

    • Vic introduced his 1-3-7 rule as an aggressive timeline for lean, AI-powered implementation:

      • 1 Day: Build the product skeleton. This means creating the core functionality, even if it's manual (e.g., a Google Doc or PDF prototype).

      • 3 Days: Publish a sales/marketing funnel. This involves setting up the mechanisms to acquire initial users or customers and test market traction.

      • 7 Days: Only if tangible traction is proven within the first three days, invest up to 7 dedicated development days on the Version 1 (V1) of the product.

    • This rule aggressively drives lean development, forces teams to prioritize essential features, and encourages the search for no-code/automation shortcuts to accelerate deployment.

Computational Thinking – 4 Canonical Stages

  1. Decomposition – The process of breaking down a large, complex idea or problem into smaller, more manageable, and independent bite-size chunks. This makes the overall problem less daunting and easier to tackle.

  2. Pattern Recognition – Identifying similarities, recurring themes, or common structures within the decomposed parts of the current problem, as well as drawing parallels with solutions from prior work or experience. This helps in reusing solutions and optimizing efficiency.

  3. Abstraction – Focusing on the essential information that truly matters while ignoring noisy, irrelevant details. This involves zooming out to understand underlying principles and zooming in on the critical variables that directly influence the outcome.

  4. Algorithm Design – Crafting precise, step-by-step instructions or a sequence of operations to solve the decomposed problem. This can take various forms, such as code, a no-code automation flow, or a standard operating procedure (SOP).

Mindset Mantras (repeat before building)

  • “There is an API for this.”: Encourages seeking existing integrations and services rather than building everything from scratch.

  • “AI is good at this.”: Prompts consideration of where AI can efficiently solve or automate specific tasks.

  • “Maybe I already have a building-block for this.”: Promotes leveraging previously built components or modules to accelerate development and avoid redundant work.

Practical Illustrations

  • Island-Survival Case (non-technical example to demonstrate universality of computational thinking):

    • Decomposition: The overarching problem of island survival is broken down into critical needs: Food / Water / Shelter / Protection / Rescue. Each of these can be further decomposed into sub-tasks (e.g., Fishing \rightarrow Trap | Spear).

    • Pattern Recognition: This stage involves identifying common resources or elements that appear across multiple decomposed branches. For instance, items like Fire & Coconuts might appear necessary for multiple survival needs.

    • Abstraction: Prioritizing high-leverage elements by focusing on what truly matters. If Fire is mentioned 6 times across different needs, it signifies high priority (e.g., Fire = 6 mentions \Rightarrow highest priority).

    • Algorithm: Crafting a step-by-step flowchart with clear decision nodes to guide actions (e.g., “Find coconuts?” \rightarrow yes/no branches).

  • Technical mini-projects:

    • “Automate video shorts from long podcasts” \rightarrow ChatGPT was used to outline the stages: Transcribe (using Whisper API) \rightarrow Detect key moments (using GPT-4) \rightarrow Cut video (using Shotstack) \rightarrow Add formatting.

    • “Automate course creation” \rightarrow An AI-generated Airtable org-chart was used to structure the process: Outline content \rightarrow Create multimedia lessons (script via GPT-4, slides via Canva API, voice via HeyGen) \rightarrow Publish to LMS.

  • Output-Input Backwards Reasoning (Project Status Dashboard):

    • This technique involves starting with the final desired output, e.g., “Overall Project Status”.

    • Then, identify the necessary upstream inputs that contribute to this output: Budget, Timeline, HR, Sales.

    • For each input, define sub-metrics (e.g., Plan vs Actual timeline for Timeline) and then compute the current status based on these metrics.

Tooling & Data Structures

  • Airtable Extensions used:

    • Org Chart – visually represents parent/child records to aid in decomposition.

    • Flowchart – facilitates quick abstraction diagrams directly within the Airtable grid.

  • Variable Matrix for Selection Decisions:

    • This structured approach helps in making informed decisions for options like tools or markets.

    • Rows = different options (e.g., various SaaS tools, potential markets).

    • Columns = criteria for evaluation (e.g., price, features, target population, GDP/capita).

    • Values are normalized to a 0-5 scale to ensure comparability across different criteria.

    • A formula is applied to calculate a weighted score: Scorei=\frac{\sum wk x{ik}}{\sum wk}, where w*k is the weight of criterion k, and x_{ik} is the score of option i on criterion k.

    • A boolean Reject column is added via formula (e.g., price > $4 \lor lacks-key-feature \rightarrow TRUE) to automatically disqualify unsuitable options.

  • Demonstrated for:

    • Picking a flow-chart SaaS.

    • Choosing an EU market for EV-charging hardware, using criteria such as population, GDP/capita, democracy index, electricity price, and English-proficiency, with weighted scoring applied.

Abstraction-Specific Frameworks

  • Early Micro-Pivoting:

    • Identify steps that are likely to be costly or unreliable early in the project lifecycle.

    • If automation for a specific step appears shaky or too expensive, replace it with inexpensive human labor (e.g., employing a $$50/week Upwork assistant) to enable launching sooner and gather real-world data.

  • Roadblock & Uncertainty Analysis:

    • List all critical unknowns and potential roadblocks (e.g., cost uncertainties, technical feasibility, data reliability issues).

    • Critically, tackle the riskiest chunk first, not last, to avoid late-stage project collapse due to unforeseen showstoppers.

  • Abstraction Flowchart:

    • Initially focus only on the high-level branch order of the process, hiding low-level logic until more clarity is gained or stakeholder sign-off is secured.

Algorithm Design Tips

  • Often, the quickest path to designing an algorithm is to open a no-code canvas (like Make, n8n, or Flowise) and build while thinking. The visual nodes within these platforms often serve as an implicit algorithm chart.

  • It is still possible to formalize the algorithm in an external diagram if detailed stakeholder sign-off or rigid documentation is required.

AI Collaboration Techniques

  • Use ChatGPT to:

    • “Identify key variables for X” – helpful for initial decomposition and abstraction.

    • “Decompose Y into hierarchical bullet list” – for structuring complex problems, which can then be pasted into tools like Logseq/Obsidian.

    • Produce CSV for Airtable org-chart – Vic shared a prompt template for generating data directly usable in Airtable's Org Chart extension.

  • Combine GPT-4-o1 (known for deep reasoning capabilities) with a “Browse/Code Interpreter” thread to access fresh search results and perform data analysis for richer insights.

  • Build a Custom GPT seeded with:

    • Your personal tool list.

    • A library of mastered Make modules or blueprints.

    • This approach helps keep AI suggestions within your familiar ecosystem and leverages your existing knowledge base.

Building-Block Library (work-in-progress)

  • This innovative concept encourages organizing reusable solutions and components. Each record in this library stores:

    • Name (e.g., “Flowise Agent Worker”).

    • Category (e.g., LLM, Vision, Search, Make-Module, UI Widget…).

    • Tools/APIs required for its implementation.

    • Tested use-cases & links to guide/videos for practical reference.

  • Learners were encouraged to copy the provided Airtable base and continuously update their personal building-block library; this library could later be exported as a CSV file to provide custom context for a Custom GPT.

Numerical & Formula Nuggets

  • Weighted scoring formula (Airtable example):
    Weighted_Score = \frac{w1x1 + w2x2 + \dots + wnxn}{\sum_{k=1}^{n} w*k}

  • Reject logic example (for filtering options):
    \text{Reject} = (\text{PriceMonthly}>4) \lor (\neg\text{HasDrag}) \lor (\neg\text{HasShapes})

  • 1-3-7 timeline expressed as a sequence of durations:
    t{product}=1\,\text{day},\; t{sales}=3\,\text{days},\; t_{buildV1}=7\,\text{days}

Community & Resources

  • Recording + Airtable links of the session will be released approximately 24 hours post-session.

  • Office Hours are held every Friday for Q&A and further discussion.

  • Upcoming class (26 Nov): “Databases meet AI – opportunities of Airtable AI”, indicating a continued series of learning opportunities.

Closing Fun

  • Vic premiered an AI-generated song titled “Warriors of Creation” that creatively featured session key-words (such as OODA, MVP, Decomposition…), further highlighting the practical applications of AI. The link to the song was shared in the chat.