Articles
Verify a Citation Before You Use It
Resolve one reference to a matching work, record the version, and distinguish identity from content verification.
section
Articles
Focused guides that turn computing tools into understandable, reusable student workflows.
Articles
Keep Research Notes Connected to Their Sources
Reopen one source passage from a saved note and identify which text is quotation, paraphrase, or personal inference.
Articles
Find the Original Source Behind a Research Summary
Locate one original source and identify the section needed to investigate a research question.
Articles
Does This Source Actually Support Your Sentence?
Revise one overbroad sentence and attach a precise source location and remaining limitation.
Articles
Compare Studies Before Calling Them Contradictory
Write a comparison paragraph that identifies comparable conditions and leaves unresolved disagreement explicit.
Articles
Write a Bounded Task for an AI Coding Agent
Give an AI coding agent a clear outcome, exact scope, authority boundary, success criteria, and evidence requirements for one reviewable change.
Articles
Protect Student Data Before You Share Anything with AI
Reduce an AI request to the minimum permitted evidence, replace real values when possible, and stop when sanitization cannot protect the material.
Articles
Check Whether AI Is Replacing Your Learning
Close the chat and test whether you can explain, reproduce, transfer, and verify the method you used with AI assistance.
Articles
Calendar Event or Task? Choose by What Must Happen
Decide whether a class, deadline, study session, or assignment belongs on a calendar, in a task list, or in both without duplicating the whole plan.
Articles
Handle LMS Course Changes Before They Become Surprises
Use LMS alerts, clarify conflicting dates or instructions, and preserve simple evidence when a surprise course change causes a problem.
Articles
Run a Semester-Start Readiness Audit and Tool Check
Verify course access, source files, required tools, submission paths, and recovery contacts before a new term begins.
Articles
Organize LMS Downloads and Lecture Notes into a Clean Course Workspace
Route one course's downloads, notes, assignments, and source files into a small workspace without losing context or creating duplicate copies.
Articles
Find AI Information Through Builders, Not Just Influencers
Use interpreters to discover questions, builders to find firsthand context, and primary evidence to reach a bounded conclusion about an AI claim.
Articles
Extract Deadlines and Hard Rules from a Syllabus or LMS
Turn course information from a syllabus or LMS into a source-linked plain-text register of milestones, hard rules, open questions, and verification states.
Articles
Build a Course Dashboard in Markdown
Create a small Markdown index for one course that connects source files, milestones, current status, open questions, and the next action.
Articles
Automate Due-Date Reminders Without Bloated Apps
Turn a verified course milestone list into a small, reviewable reminder flow without duplicating dates across several productivity tools.
Articles
Adapt Shared Agent Skills to Your Own Workflow
Compare agent skills on a safe task, adapt only what fits your workflow, and keep the source, permissions, and rollback path visible.
Articles
Recovering Git History and Lost Code
Learn how to inspect local Git history, reflogs, and recovery copies without rewriting the repository before you know which version is correct.
Articles
Post-Crisis Review and System Hardening
Turn a technical incident into a small, tested improvement to your files, backups, documentation, or recovery workflow.
Articles
Emergency Triage for Broken Assignments and Files
A calm, evidence-first protocol for protecting files, assessing damage, and choosing the next recovery step when student work breaks near a deadline.
Articles
Communicating with Instructors During a Technical Crisis
Write a short, honest, evidence-backed message when a technical problem may affect an assignment, deadline, or submission.
Articles
An Obsidian Vault for College Records You Can Keep and Explain
Build a 6-folder lifecycle college Obsidian vault for durable personal records, event chronologies, and AI-assisted knowledge management.
Articles
What K–12 Schools Can Learn from AI-Supported Mastery Models
Evaluate which parts of an AI-supported mastery model merit a bounded school pilot without treating one private school as proof for an education system.
Articles
Use Notion as a Reusable, AI-Connected Workspace
Combine a reusable Notion template, external-agent access, built-in Notion AI, and export while keeping permissions and review explicit.
Articles
Understand Linux Filesystem Permissions
Read Linux ownership and mode bits, explain directory permissions, and practice least-privilege changes in a disposable folder.
Articles
Turn Daily Information Into a Journal You Can Use
Process scattered daily captures into a chronological journal, durable learning, verified claims, and correctly routed actions.
Articles
Set Up Linux Users, Groups, and sudo Safely
Inspect Linux identities, separate daily work from administrative elevation, and verify sudo access without weakening account security.
Articles
Set Up Git, SSH, and Course Toolchains on macOS
Build the smallest macOS development environment required by one course, with verified Git identity, optional SSH authentication, and isolated project dependencies.
Articles
Set Up Git, SSH, and Course Toolchains on Linux
Build one course-bounded Linux development environment with verified Git identity, host-specific SSH access, required runtimes, and a reproducible project check.
Articles
Set Up a Safe Mac for College
Establish Mac ownership, account roles, FileVault recovery access, software updates, and a safe starting record before installing course tools.
Articles
Recover Linux from a Broken Setup
Prepare and rehearse a layered Linux recovery plan without modifying the installed system, then define stop conditions for real repair or reinstallation.
Articles
Recover a Student Mac from a Broken Setup
Rehearse Mac recovery without erasing the device by verifying accounts, FileVault access, backups, project restoration, setup artifacts, management, and macOS Recovery boundaries.
Articles
macOS Terminal and zsh for Complete Beginners
Learn how the macOS Terminal application, zsh shell, prompt, current directory, command path, help, and exit status fit together.
Articles
Linux Terminal and Shell Fundamentals
Identify the Linux terminal and shell, navigate paths, quote arguments safely, use local help, and verify command results.
Articles
Is a Computer Science Major Still Worth It in the AI Era?
Evaluate a computer science degree by its curriculum, learning support, cost, alternatives, and evidence—not by broad predictions about AI.
Articles
Install Mac Apps Deliberately with the App Store and Homebrew
Choose one responsible installer and updater for each Mac app or command-line tool, then install and verify one approved item.
Articles
Install and Verify Xcode Command Line Tools
Decide whether a Mac needs Apple's standalone Command Line Tools or full Xcode, then install and verify the selected developer directory and package version.
Articles
Install and Update Linux Packages Deliberately
Identify the active Linux package system, inspect one package and transaction, then install or update it with distribution-specific commands and verification.
Articles
Inspect Linux Services, Processes, and Logs
Investigate Linux processes, systemd services, and journal entries with read-only commands before attempting a change.
Articles
From Autocomplete to Agents: How AI Coding Methods Are Evolving
Adapt to AI coding tools by strengthening specification, context, tests, bounded delegation, diff review, and explanation.
Articles
Choose an AI Agent by Where the Work Runs
Select an AI-agent surface by data location, execution continuity, permissions, reviewability, and export—not a product leaderboard.
Articles
Choose a Linux Distribution for College
Choose a supported Linux distribution by checking course requirements, hardware, documentation, maintenance, and recovery before installing.
Articles
Build a Reproducible macOS Setup
Record a course-bounded Mac environment with a reviewed Brewfile, documented dotfiles, safe bootstrap steps, and read-only verification.
Articles
Build a Reproducible Linux Setup
Create and test a secret-free Ubuntu 26.04 LTS setup repository with a curated package manifest, selected configuration, bootstrap steps, and read-only verification.
Articles
Use a Chatbot to Complete a Complicated Template
Turn a long template into a guided chatbot interview, answer one question at a time, and export a complete record without invented information.
Articles
Three Human Talents to Practice in the AI Era
Practice broad foundations, initiative, and mental robustness through a semester plan with observable work and review.
Articles
Structured Languages Are Thinking Tools in the AI Era
Use prose, structured documents, schemas, and code to expose assumptions and make parts of AI-assisted work mechanically checkable.
Articles
Grow With Skills: Improve the Agent While You Work
Improve a personal agent skill from observed work, selectively adapt attributed ideas from a shared skill, and keep only revisions that pass fresh-task tests.
Articles
Follow Important AI Updates Without Chasing Every Announcement
Build a scheduled, low-noise routine that turns relevant AI updates into verified decisions instead of continuous news consumption.
Articles
When Not to Invest Deeply in an AI Tool
Decide whether to deepen, operate, monitor, or ignore an AI tool using transferability, evidence, switching cost, and a bounded trial.
Articles
Use Git Worktrees for Parallel AI Agents
Isolate parallel AI-agent tasks in linked Git worktrees, then review and integrate each result deliberately.
Articles
Test an AI-Generated Claim with the Scientific Method
Turn one AI-generated claim into a proportionate test with explicit assumptions, independent evidence, and a bounded conclusion.
Articles
Maintain a Personal Knowledge Base with AI
Use AI for a bounded, reversible knowledge-base maintenance pass while preserving privacy, context, links, and student control.
Articles
Choose Text and Data Formats for People, Software, and LLMs
Choose Markdown, JSON, XML, YAML, CSV, or prose from the interface requirements of people, software, and LLM workflows.
Articles
Your First Merge Conflict Should Be Deliberate
Create and resolve a controlled Git merge conflict in a disposable repository so the real event is understandable.
Articles
Your Backup Is Only Real If You Can Restore It
Test one small file restoration, verify its contents, and document the evidence needed for future recovery.
Articles
Write a Reproducible Bug Report
Give a classmate, instructor, maintainer, or AI enough safe evidence to reproduce and investigate a failure.
Articles
Windows Terminal and PowerShell for Complete Beginners
Learn how Windows Terminal profiles, PowerShell prompts, cmdlets, parameters, and built-in help fit together.
Articles
Windows Paths, File Extensions, and Hidden Files
Read Windows paths, distinguish full and relative locations, and show file extensions and hidden items safely.
Articles
Why Plain Text Works So Well with Git, CLI Tools, and AI
See how visible characters and lines let Git, command-line tools, and AI-assisted workflows share one inspectable interface.
Articles
When Productivity Optimization Becomes Procrastination
Use demonstrated problems, outcome tests, time limits, and stop rules to keep tool maintenance from replacing student work.
Articles
When Notion Is the Better Tool
Recognize group work that benefits from shared database pages, filtered views, comments, and explicit permissions.
Articles
What Kind of Note Are You Writing?
Distinguish capture, course, concept, project, and reflection notes so each note has a clear job and lifecycle.
Articles
What Is Plain Text, and Why Should a Student Care?
Recognize plain-text files and understand when their portability, searchability, and simple structure help student work.
Articles
What Git Is Actually Tracking
Build a correct mental model of the Git repository, working tree, staging area, and committed history.
Articles
Use Obsidian, Notion, Git, and Office Without Duplicating Everything
Assign one canonical responsibility to personal notes, shared coordination, technical source, and required deliverables.
Articles
Use AI as a Tutor, Not an Answer Vending Machine
Use hints, questions, layered explanations, practice, and feedback to keep AI-assisted work centered on learning.
Articles
Use `AGENTS.md` to Teach an AI About a Repository
Record durable repository conventions, commands, scope, and review expectations while keeping one-time requests in the prompt.
Articles
Upgrade Software Safely with WinGet
Inspect available WinGet upgrades, update one approved package intentionally, and verify behavior and recovery.
Articles
The Small CLI Toolkit Worth Learning
Recognize seven useful CLI tools and build a learning queue driven by real course and project needs.
Articles
The Semester-End Technical Review
Archive course work, test recovery, review tools, update setup documentation, preserve repeated work, and select portfolio evidence.
Articles
The Capture–Verify–Crystallize Loop
Turn an AI-assisted result into a verified asset that works independently of the original conversation.
Articles
Test the Expected, the Boundary, and the Invalid
Design a small meaningful test set covering normal behavior, important boundaries, and invalid inputs.
Articles
Terminal, Shell, and Command: Three Different Things
Learn the vocabulary that separates the terminal window, the shell interpreting input, and the commands doing the work.
Articles
Ten PowerShell Operations Every Student Should Practice
Practice navigation, listing, reading, creating, copying, moving, searching, processes, pipelines, and help in a safe folder.
Articles
Sync, Git, and Backup Solve Different Problems
Build a three-layer protection plan by separating file synchronization, version history, and recovery copies.
Articles
Stop Naming Files “Final-Final-2”
Build a predictable filename convention and know when filenames, document history, or Git should manage revisions.
Articles
Source Files and Generated Files Are Not the Same
Learn which project files must be preserved, which can be regenerated, and how that distinction guides Git and backup decisions.
Articles
Should This Be a Note, Checklist, Script, or Skill?
Choose the smallest reuse level that fits understanding, human judgment, deterministic work, project guidance, or agentic interpretation.
Articles
Seven Terminal Concepts Every Beginning Programmer Needs
Practice seven portable terminal concepts that make command-line work understandable across operating systems.
Articles
Set Up a Safe Windows Account for College
Establish Windows account ownership, daily privileges, Windows Hello, updates, recovery, and institution-management boundaries.
Articles
Rebuild a Student Windows PC from Documentation
Rehearse Windows recovery safely with backups, manifests, setup documentation, and project repositories before any destructive reset.
Articles
Prefer Reversible Changes
Use inspection, checkpoints, small steps, least privilege, verification, and rollback to make technical changes safer.
Articles
Pipes and Redirection: The Composable Power of the CLI
Understand standard input, output, error, pipes, and safe output redirection before learning shell-specific syntax.
Articles
Package a Repeatable AI Workflow as a Skill
Recognize repeated multi-step agent work that belongs in a tested skill with instructions, references, scripts, and a defined output.
Articles
Open the Project Folder, Not Just the Code File
Work from the project root so source, configuration, dependencies, tests, documentation, and terminal commands stay in context.
Articles
Obsidian or Notion? Start with Your Requirements
Choose a note system by testing ownership, collaboration, offline, structure, and export requirements.
Articles
Never Blindly Paste a Command from the Internet or an AI
Evaluate every segment, target, privilege, network action, and secret exposure before running an unfamiliar command.
Articles
Native Windows or WSL: How to Choose
Choose native Windows or WSL from course expectations, toolchain, filesystem ownership, editor integration, and support constraints.
Articles
Markdown, Word, or PDF: Choose the Right Format
Choose Markdown, Word, or PDF based on editing, review, layout, conversion, and delivery requirements.
Articles
Markdown in 30 Minutes
Learn the small set of Markdown syntax needed to write and verify a useful first README.
Articles
Learn to Ask a Command for Help
Use a command-discovery checklist to find local help, read usage notation, and verify unfamiliar options.
Articles
Install Your First Developer Tools with WinGet
Search, inspect, install, list, and verify one approved Windows developer tool by exact WinGet package ID.
Articles
Install Only What the Course Requires
Build a course-compatible programming environment without adding conflicting global tools or undocumented dependencies.
Articles
Inspect Before You Change
Use read-only inspection, one small change, and an after-state check to make command-line work understandable.
Articles
How to Review AI-Generated Code
Review generated code line by line for requirements, assumptions, dependencies, tests, security, scope, and explainability.
Articles
How to Make a Useful Commit
Create a small verified Git checkpoint with one logical change and a descriptive message.
Articles
GitHub Is More Than Online Storage
Understand how GitHub adds remotes, issues, pull requests, review, access, and project context around Git repositories.
Articles
Files, Folders, Paths, and Extensions Without the Mystery
Build a clear filesystem model by locating the same file in a graphical file manager and a terminal.
Articles
Editor, Language, Runtime, Compiler, and Package Manager Explained
Learn the major parts of a programming toolchain, including Git when a course uses it, and identify which component owns a problem.
Articles
Don’t Let a Useful AI Conversation Disappear
Capture a successful AI-assisted task as a durable record of the problem, reasoning, commands, risks, and verification.
Articles
Define “Done” Before You Start
Write observable success criteria for scope, behavior, tests, documentation, and delivery before beginning a project.
Articles
Debugging Is a Scientific Process
Debug with a reproducible cycle of observation, reduction, hypothesis, experiment, and verification.
Articles
CSV, Excel, or Code: How Should You Store Tabular Data?
Choose CSV, a spreadsheet, or code based on exchange, interactive analysis, presentation, and repeatable transformation needs.
Articles
Build a Small Portfolio with Depth
Present a few projects through their problems, decisions, implementation, tests, evidence, credits, and honest reflection.
Articles
Build a Reproducible Windows Setup
Record Windows packages, configuration, setup steps, and verification in a versioned, secret-free environment repository.
Articles
BitLocker and Recovery Keys Without Regret
Verify Windows drive encryption, recovery-key custody, edition differences, and non-destructive recovery access.
Articles
Before You Ask AI, Write Down What You Know
Use a known–unknown–attempt record to preserve independent reasoning and ask AI a focused, verifiable question.
Articles
Automation Is the Last Step, Not the First
Turn a stable manual workflow into documented, verified automation with monitoring and a recovery path.
Articles
Automate Deterministic Work with Code
Replace repeated prompts with tested code when inputs, outputs, operations, and failures can be defined explicitly.
Articles
Ask AI to Explain an Error Without Solving the Assignment
Build a permitted minimal reproduction and ask AI for hypotheses and investigative steps instead of replacement code.
Articles
AI Can Be Confident and Wrong
Recognize invented citations and APIs, sample-only code, hidden assumptions, and unnecessary complexity in AI output.
Articles
Academic Integrity in the Age of AI
Translate course-specific AI rules into clear boundaries for tutoring, substitution, disclosure, privacy, and published solutions.
Articles
A Weekly Note Review a Student Can Actually Maintain
Use a fifteen-minute capture, clarify, connect, and archive routine to keep student notes useful.
Articles
A Project Structure That Encourages Good Habits
Organize source, tests, documentation, scripts, and examples in a small project skeleton that makes expected work easy to find.
Articles
A Project README That Lets Someone Else Succeed
Write a project README that explains purpose, requirements, installation, running, testing, and verification.
Articles
A Practical Prompt Library for Students
Use a small set of prompt patterns for hints, investigation, explanation, tests, reasoning review, quizzes, and manual verification.
Articles
A College Folder Structure That Can Survive Four Years
Create a simple academic folder structure organized by year, term, and course without adding unnecessary complexity.
Articles
A Beginner’s First Programming Workflow
Use an understand–plan–change–run–test–checkpoint loop that works with Git or a course's required submission method.
Articles
`git status` and `git diff`: Your Safety Instruments
Inspect untracked, modified, staged, and unstaged changes before committing or accepting an AI edit.
Articles
Write a Personal System Charter Before Choosing Tools
Define outcomes, constraints, non-goals, ownership, and evidence before selecting applications or configurations.
Articles
The Student Should Own the System
Define student, parent, and mentor roles that turn computer setup and troubleshooting into transferable skills.
Articles
Terminal-First, Text-First, Reusable-by-Default
Use three practical principles to make student computing work visible, portable, and easier to repeat.
Articles
Start Here: A Practical Student Computing Workflow
Begin with one working-log entry, then add four practical computing practices when they support a current need.
Articles
Start a Working Log Before You Change Anything
Create a chronological record that makes setup, troubleshooting, and AI-assisted work easier to understand and verify.
Articles
Don’t Build a Perfect Setup—Build a System You Can Understand
Evaluate tools by the outcomes they support, the complexity they add, and the student's ability to maintain and recover the system.