<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by LabEx on Medium]]></title>
        <description><![CDATA[Stories by LabEx on Medium]]></description>
        <link>https://medium.com/@labexio?source=rss-991c67b047ab------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*HfvuxBPmb_boLy1IqC1Qmg.jpeg</url>
            <title>Stories by LabEx on Medium</title>
            <link>https://medium.com/@labexio?source=rss-991c67b047ab------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 23:13:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@labexio/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Linux Learning Roadmap for 2026: From Your First Command to Running a Service]]></title>
            <link>https://labexio.medium.com/linux-learning-roadmap-for-2026-from-your-first-command-to-running-a-service-28fe133cf6dd?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/28fe133cf6dd</guid>
            <category><![CDATA[system-administration]]></category>
            <category><![CDATA[shell]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Mon, 07 Sep 2026 05:51:09 GMT</pubDate>
            <atom:updated>2026-09-07T05:51:09.283Z</atom:updated>
            <content:encoded><![CDATA[<p>A service cannot read its configuration file. You can find the file and open it yourself, but restarting the service changes nothing. What would you inspect next: the path, the file’s owner, the directory permissions, or the identity running the service?</p><p>That question connects several parts of Linux that beginners often study separately. A useful learning roadmap should help you make those connections. Its checkpoints should tell you what you can now investigate and fix, not just which commands you have seen.</p><p>The route below starts with a terminal and ends with maintaining a small service: checking its files, reading its logs, tracing a connection, and recovering a configuration. Use the checkpoints to choose your starting point. Looking up syntax is allowed; being able to explain and verify the change is the test.</p><h4>The roadmap at a glance</h4><ul><li><strong>Choose an environment</strong></li><li><strong>Learn to work with:</strong> Distribution, shell, user, system capabilities</li><li><strong>Move on when you can…:</strong> Identify where commands run and which administration tasks the environment supports</li><li><strong>Navigate and edit</strong></li><li><strong>Learn to work with:</strong> Paths, help, files, directories, a text editor</li><li><strong>Move on when you can…:</strong> Find a configuration, edit a copy, and check exactly what changed</li><li><strong>Control access</strong></li><li><strong>Learn to work with:</strong> Users, groups, ownership, file and directory permissions</li><li><strong>Move on when you can…:</strong> Give the intended identity access and verify the access boundary</li><li><strong>Process text</strong></li><li><strong>Learn to work with:</strong> Standard streams, pipes, filters, exit status</li><li><strong>Move on when you can…:</strong> Produce a repeatable report from a log file</li><li><strong>Inspect a running system</strong></li><li><strong>Learn to work with:</strong> Processes, packages, services, journals</li><li><strong>Move on when you can…:</strong> Use evidence to recover a failed service</li><li><strong>Trace connections</strong></li><li><strong>Learn to work with:</strong> Addresses, routes, DNS, listening sockets, SSH</li><li><strong>Move on when you can…:</strong> Separate a name-resolution problem from a connection or service problem</li><li><strong>Automate and recover</strong></li><li><strong>Learn to work with:</strong> Scripts, disk space, archives, scheduling</li><li><strong>Move on when you can…:</strong> Run a task reliably and restore a selected file from its backup</li></ul><p>This is a learning sequence, not a fixed number of weeks. If you already edit files and understand permissions, try those checkpoints and begin where your explanation breaks down. If a later task exposes a gap, return to the relevant stage.</p><p>The scope is consistent with established introductory curricula. <a href="https://www.lpi.org/our-certifications/exam-010-objectives/">LPI Linux Essentials</a> includes files, permissions, archives, recovery, and simple scripts. The Linux Foundation’s <a href="https://training.linuxfoundation.org/training/introduction-to-linux/">Introduction to Linux</a> also covers processes, networking, Bash, and local security. Neither source establishes a universal learning order; the order here follows the dependencies of the practice tasks.</p><h4>Choose an environment you can inspect</h4><p>Pick one Linux distribution for the main route. Ubuntu is a practical choice for following the package-management documentation linked below. Learn its conventions first, then compare another distribution when you have a reason to do so.</p><p>A terminal is the interface you type into. A shell interprets your commands. The distribution supplies the operating-system environment and its package and configuration conventions. Open Bash for the examples in this article and inspect the environment:</p><pre>cat /etc/os-release<br>printf &#39;%s\n&#39; &quot;$BASH_VERSION&quot;<br>id<br>pwd</pre><p>Record the distribution, Bash version, current identity, and working directory. These details explain many differences between a tutorial and the system in front of you. A command that exists on one machine may need an additional package on another.</p><p>On Windows, WSL is an option, including for some service-management practice. <a href="https://learn.microsoft.com/en-us/windows/wsl/systemd/">Microsoft documents systemd support in WSL</a>, with requirements and configuration that depend on the installation. Check the actual environment before assuming that a service command will work. For boot, disk, and recovery exercises, choose a disposable Linux VM that exposes the capabilities the exercise requires.</p><p>Also distinguish a container from a complete VM. <a href="https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/">Docker describes containers as isolated processes sharing a kernel</a>. A container shell can be useful for file and scripting work, but its presence does not establish that you can manage a full guest’s boot process or services.</p><p>If you want a structured starting point, the <a href="https://labex.io/learn/linux">LabEx Linux path</a> links to Linux courses and practice. <a href="https://labex.io/courses/quick-start-with-linux">Quick Start with Linux</a> is the short entry route; choose a lab environment appropriate to the task as you progress.</p><h4>Navigate, edit, and check your changes</h4><p>Start with absolute and relative paths, hidden files, and the relationship between your current directory and a command’s arguments. Practise finding help with --help and man. Learn enough of one editor to open, search, change, save, and exit a file.</p><p>Build a small practice directory that you will reuse later. Run this once in a new Bash session; keep the terminal open for the subsequent examples. mktemp creates a fresh directory rather than reusing an existing project:</p><pre>practice_dir=$(mktemp -d)<br>cd &quot;$practice_dir&quot;<br>mkdir -p service/{config,logs,backups}<br>printf &#39;port=8080\n&#39; &gt; service/config/app.conf<br>cp service/config/app.conf service/config/app.conf.before<br>printf &#39;%s\n&#39; &quot;$practice_dir&quot;</pre><p>The configuration is a practice fixture, not a configuration format for an installed server. Open app.conf in your editor and change the port to 8081. Then inspect the difference:</p><pre>diff -u service/config/app.conf.before service/config/app.conf</pre><p>Explain which line changed and which file contains the original. A difference makes diff return status 1; that is its way of reporting unequal inputs, not automatically a command failure.</p><p>Your checkpoint is to locate this file from another working directory, edit a copy, and verify the result. If you cannot predict which path a command will touch, spend more time here before practising recursive operations.</p><p>The <a href="https://labex.io/courses/linux-for-noobs">Linux for Noobs course</a> provides the main practice spine for this roadmap. Its public syllabus covers file operations and command help, then continues through permissions, text processing, processes, services, networking, scripting, and recovery. The exercises below are article examples, not reproductions of its lab instructions.</p><h4>Understand which identity needs access</h4><p>Read ls -l output in terms of owner, group, and everyone else. Then learn why directories have permission bits too. Directory search permission affects access through a path; reading a file involves more than the bits on that final file.</p><p>In the practice directory, inspect both the file and its containing directory:</p><pre>id<br>ls -ld service service/config<br>ls -l service/config/app.conf<br>chmod 600 service/config/app.conf<br>ls -l service/config/app.conf</pre><p>The mode change gives the owner read and write permission and removes the group’s and others’ mode permissions. This is an appropriate exercise for an owner-only file. It does not prove that the same mode would work for a service running as another user.</p><p>That distinction is the checkpoint: state which identity needs access, choose ownership and permissions to match, and test as that identity in an administration lab. Also test the identity that should lack access. Reading the file as your own user proves only your own access. Later, ACLs and mandatory access controls can add further constraints beyond ordinary mode bits.</p><p><a href="https://labex.io/lesson/file-permissions">Linux Journey’s file-permissions lesson</a> is a useful companion when you need to decode the permission string. Keep returning to the opening service problem: which user is actually trying to read the configuration?</p><h4>Turn output into a repeatable report</h4><p>Before learning long pipelines, understand standard output, standard error, and redirection. Learn a few filters well: grep for selection, cut or awk for fields, and sort with uniq for grouping.</p><p>Create a deliberately simple log fixture:</p><pre>printf &#39;%s\n&#39; \<br>  &#39;INFO started&#39; \<br>  &#39;ERROR config-unreadable&#39; \<br>  &#39;ERROR config-unreadable&#39; \<br>  &#39;ERROR connection-refused&#39; &gt; service/logs/app.log<br><br>awk &#39;$1 == &quot;ERROR&quot; { print $2 }&#39; service/logs/app.log |<br>  sort |<br>  uniq -c</pre><p>For this fixture, the report should count two config-unreadable events and one connection-refused event. It relies on a specific input format: a severity followed by a single-word event. Real logs may use timestamps, quoted fields, JSON, or multiline records; inspect the format before choosing a parser.</p><p>Save the report in a file, add another event, and regenerate it. Check that the new count matches the input. Then try a missing input file and observe the error separately from the report.</p><p>Exit status becomes important here. In Bash, a pipeline normally reports the last command’s status. With pipefail, a failure earlier in the pipeline can affect that result. Consult the <a href="https://www.gnu.org/software/bash/manual/html_node/Pipelines.html">Bash pipeline documentation</a> before treating an empty output file as proof of success.</p><h4>Inspect processes, packages, services, and logs</h4><p>Now move from prepared files to a running system. Learn to identify a process, its owner, its command, and its resource use. Practise process termination in an exercise with a known target, and distinguish that process from unrelated work.</p><p>Use the distribution’s package manager to install software and inspect what is installed. <a href="https://ubuntu.com/server/docs/how-to/software/package-management/">Ubuntu’s package-management guide</a> explains APT and related tools. Treat that as Ubuntu-specific guidance; RPM-based systems have a different toolchain.</p><p>A service manager adds another layer: it manages a program according to a unit’s configuration and lifecycle rules. On a systemd-based practice VM, select a service supplied by the exercise and inspect its status, recent journal entries, and unit configuration. Learn the difference between starting it now and enabling it for future activation at boot. The <a href="https://www.freedesktop.org/software/systemd/man/latest/systemctl.html">systemctl manual</a> explicitly distinguishes enabling from starting.</p><p>Do not make restart the whole troubleshooting procedure. A useful investigation records the failure, reads the relevant log entry, identifies a cause, changes one thing, and checks the result. A unit’s active state is only one check; the application must also do its intended job.</p><p>Use <a href="https://labex.io/labs/linux-recover-a-failed-service-725413">Recover a Failed Service</a> as a practice destination. The checkpoint is an explanation of the cause and evidence that the recovered service works. If the task includes persistence across reboot, verify that separately in an environment designed for it.</p><h4>Trace a connection before changing the firewall</h4><p>A running process does not guarantee a reachable service. Learn enough addressing, routing, DNS, and ports to separate the layers. On a Linux system with the relevant tools installed, start with read-only inspection:</p><pre>ip addr<br>ip route<br>ss -ltn</pre><p>These answer different questions: which addresses exist, where packets are routed, and which TCP sockets are listening. A loopback listener and a listener on an external interface have different reachability. A firewall is another boundary; opening a port cannot make a nonexistent listener appear.</p><p>For a lab-provided HTTP service, first test the intended local address and port, then the intended remote path. Check hostname resolution when using a name. A successful local request does not prove remote connectivity, and a failed ping alone does not establish that HTTP is unavailable.</p><p>Next learn SSH login, key-based authentication, and file transfer. <a href="https://ubuntu.com/server/docs/how-to/security/openssh-server/">Ubuntu’s OpenSSH guide</a> provides the client/server context and configuration guidance. Keep a working session available when an exercise changes remote-access configuration, and verify a new connection before relying on the change.</p><p>The checkpoint is to explain whether a failure concerns name resolution, routing, listening, filtering, or the application response. The course exercise <a href="https://labex.io/labs/linux-correct-a-service-bind-address-725411">Correct a Service Bind Address</a> gives this stage a bounded practice target.</p><h4>Automate a task and prove you can recover</h4><p>Turn the log report into a Bash script only after you understand its commands. Give it an input-path argument, quote expansions, check missing or unreadable inputs, and return a nonzero status on failure. Practise conditions, loops, and functions as the task needs them; <a href="https://labex.io/courses/shell-for-beginners">Shell for Beginners</a> offers additional exercises in those areas.</p><p>Test an ordinary path, a path containing spaces, an empty log, and a missing file. <a href="https://www.shellcheck.net/wiki/SC2086">ShellCheck’s quoting explanation</a> shows why unquoted expansion can change arguments through word splitting and globbing. Use the checker alongside execution tests. If you use an AI assistant to suggest a script, apply the same tests and explain the changes before adopting it.</p><p>Before scheduling backups, learn to inspect filesystem capacity with df and directory usage with du. Understand where the archive will be written and whether there is room for it. Partitions, LVM, and boot recovery can wait for a deeper administration track.</p><p>Back in the same practice directory, create an archive and restore into a separate location:</p><pre>tar -czf service/backups/config.tar.gz -C service/config app.conf<br>tar -tzf service/backups/config.tar.gz<br>mkdir -p service/restore-check<br>tar -xzf service/backups/config.tar.gz -C service/restore-check<br>cmp service/config/app.conf service/restore-check/app.conf</pre><p>For an unchanged source, cmp should produce no output and return zero. That checks the recovered file&#39;s contents. It does not establish a complete backup policy, off-machine protection, or application recovery.</p><p>Only then schedule the task using cron or, on an appropriate system, a systemd timer. Use explicit paths and capture failures: scheduled execution may not have the same working directory or environment as your interactive terminal. Verify an actual scheduled run, then restore a selected file. <a href="https://labex.io/labs/linux-restore-a-configuration-from-backup-725409">Restore a Configuration from Backup</a> is a focused next exercise.</p><h4>Choose a direction after the core checkpoints</h4><p>The 2026 part of this roadmap is its checked environment and resource guidance, not a new set of Linux fundamentals. Course listings and platform defaults can change; use the documentation for the system you actually run.</p><p>For development, continue into Git, language environments, and containers. Your knowledge of paths, users, processes, ports, and logs gives you specific questions to ask when a containerized application fails.</p><p>For system administration, deepen storage, boot recovery, network configuration, and security policy. If you choose certification, map your skills against its current objectives. The <a href="https://www.redhat.com/en/services/training/ex200-red-hat-certified-system-administrator-rhcsa-exam">RHCSA EX200 page</a> currently specifies RHEL 10 and includes areas such as LVM and SELinux beyond this core route. This article is not an exam-coverage claim.</p><p>For security, continue with service exposure, access boundaries, and privileged automation. <a href="https://labex.io/courses/linux-security-for-devsecops">Linux Security for DevSecOps</a> lists exercises in those areas. Learn to inspect the running system before attempting to harden it.</p><p>Before branching out, complete one small maintenance exercise without step-by-step instructions. In a disposable service lab, recover a broken configuration, verify the service’s response at its intended address, generate an error report, and restore a selected file from backup. Keep a short record of the evidence, your change, and the verification. If you can explain all three, you have a concrete basis for the next stage.</p><h4>References</h4><ul><li><a href="https://labex.io/learn/linux">LabEx Linux learning path</a> — course and practice entry points; linked course syllabi were checked on September 7, 2026.</li><li><a href="https://www.lpi.org/our-certifications/exam-010-objectives/">LPI Linux Essentials objectives</a> and <a href="https://training.linuxfoundation.org/training/introduction-to-linux/">Linux Foundation Introduction to Linux</a> — independent reference points for introductory scope.</li><li><a href="https://learn.microsoft.com/en-us/windows/wsl/systemd/">Microsoft: systemd in WSL</a> and <a href="https://docs.docker.com/get-started/docker-concepts/the-basics/what-is-a-container/">Docker: containers and VMs</a> — environment capabilities and boundaries.</li><li><a href="https://www.gnu.org/software/bash/manual/html_node/Pipelines.html">GNU Bash pipelines</a> and <a href="https://www.freedesktop.org/software/systemd/man/latest/systemctl.html">systemctl</a> — pipeline status and service-management semantics.</li><li><a href="https://ubuntu.com/server/docs/how-to/software/package-management/">Ubuntu package management</a> and <a href="https://ubuntu.com/server/docs/how-to/security/openssh-server/">OpenSSH server</a> — distribution-specific administration guidance.</li><li><a href="https://www.shellcheck.net/wiki/SC2086">ShellCheck SC2086</a> — word splitting, globbing, and quoting examples.</li><li><a href="https://www.redhat.com/en/services/training/ex200-red-hat-certified-system-administrator-rhcsa-exam">Red Hat EX200 objectives</a> — the boundary between this general route and RHEL certification preparation.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=28fe133cf6dd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux Journey, Rebuilt for Interactive Learning]]></title>
            <link>https://labexio.medium.com/linux-journey-rebuilt-for-interactive-learning-6cf545d85f18?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cf545d85f18</guid>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[linux-journey]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Tue, 01 Sep 2026 07:26:30 GMT</pubDate>
            <atom:updated>2026-09-01T07:26:30.613Z</atom:updated>
            <content:encoded><![CDATA[<p>The old Linux History page put almost everything on one screen: the lesson list on the left, the complete article in the middle, and exercises plus a quiz on the right. The material was available, but the learner had to decide how to move through it, where to pause, and whether one answer at the end was enough to check their understanding.</p><figure><img alt="The previous Linux Journey lesson page with a sidebar, full article, exercises, and a quiz" src="https://cdn-images-1.medium.com/max/1024/0*9YUEy_F_oerNU9Wl.png" /></figure><p>The new Linux Journey starts one level earlier. A course page now shows the sequence of lessons, a short outcome for each lesson, and one place to start or resume the course.</p><figure><img alt="The redesigned Getting Started course page with an ordered interactive syllabus" src="https://cdn-images-1.medium.com/max/1024/0*u7NBfjnoiLAQHr24.png" /></figure><p>That visual redesign supports a more important change: Linux Journey is no longer organized only as a collection of pages to read. Each lesson now runs as a small learning sequence built around explanation, a decision, feedback, and continuation.</p><h4>From a Syllabus to Learning Mode</h4><p>The redesigned <a href="https://labex.io/linuxjourney/courses/getting-started">Getting Started course</a> presents its 11 lessons as an ordered path. Each entry names the lesson and states what it covers, so a learner can see how Linux History leads into distribution choices and individual distribution guides before opening the first page.</p><p>Selecting <strong>Start Course</strong> opens the lesson in learning mode. Instead of displaying the entire page at once, the player begins with the first meaningful block and reveals the lesson step by step. A progress bar shows how far the learner has moved through the current lesson, while the <strong>Continue</strong> button provides a clear next action.</p><p>Course and lesson progress can be saved for signed-in learners. Signing in is not required to study the lessons; it is used to keep completion state available across devices.</p><h4>Questions Become Part of the Explanation</h4><p>The previous Linux History quiz asked one recall question after the article: who developed the Linux kernel? In the revised lesson, checks appear immediately after the ideas they depend on.</p><p>After the lesson explains that rewriting UNIX in C made it portable, for example, the learner chooses among three possible consequences. Selecting an option produces feedback for that specific choice. An incorrect answer explains the mismatch with the preceding material; the correct answer reinforces the portability principle. The lesson continues only after the learner identifies the correct answer.</p><figure><img alt="The new Linux History learning mode showing lesson progress and immediate feedback on a contextual question" src="https://cdn-images-1.medium.com/max/1024/0*lx5V-56CxJVrD6Vm.png" /></figure><p>These questions are comprehension checks, not claims that a learner has mastered Linux administration. Their job is narrower: interrupt passive scrolling at a useful moment and make the learner apply the explanation that just appeared.</p><p>The same player also provides a completion view with the lesson outcomes, a link to the next lesson, and a way to learn the lesson again. This turns the lesson boundary into part of the course flow instead of leaving navigation in a separate sidebar.</p><h4>The Content Was Revised for the New Flow</h4><p>The interface could not create this experience by itself. The Linux Journey lessons were also migrated to a structure that the player can divide into meaningful steps.</p><p>The revision preserved explanations, examples, images, and practice links when they were still accurate. It removed the old standalone exercise and quiz containers, moved useful material next to the topic it supports, and converted worthwhile questions into contextual single-choice checks. Each lesson now ends with a short summary of what the learner can explain or do.</p><p>Across the current lesson collection, every lesson in all nine supported languages contains four or five of these checks. Each option includes feedback, and each question must be answerable from material taught earlier in the lesson. The structure is designed to test the current idea without requiring unstated Linux knowledge.</p><p>The result is not a wholesale replacement of the original Linux Journey material. It is a new delivery structure for that material, with targeted revisions where a transition, explanation, or question needed to support the interactive sequence.</p><h4>Still Free, Still Open</h4><p>The redesigned <a href="https://labex.io/linuxjourney">Linux Journey</a> remains free to use, with no payment or account required to read the lessons. Creating a free account is optional and enables saved learning progress.</p><p>The lesson content also remains open source in the <a href="https://github.com/labex-labs/linuxjourney">official Linux Journey repository</a>. It is published under the CC BY-SA 4.0 license, and the repository continues to accept community contributions to lessons and translations.</p><p>You can start with <a href="https://labex.io/linuxjourney/courses/getting-started">Getting Started</a>, or inspect and improve the source material on <a href="https://github.com/labex-labs/linuxjourney">GitHub</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cf545d85f18" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Best Vibe Coding Tools in 2026: 12 Builders and Coding Agents Compared]]></title>
            <link>https://labexio.medium.com/best-vibe-coding-tools-in-2026-12-builders-and-coding-agents-compared-6ad583a2d379?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ad583a2d379</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[coding-agents]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 00:59:55 GMT</pubDate>
            <atom:updated>2026-08-20T00:59:55.539Z</atom:updated>
            <content:encoded><![CDATA[<p>The moment a Vibe Coding tool impresses me most is also when I become most cautious. One prompt can produce a polished app screen, but a polished screen is not a passed requirement. What changed, whether another person can take over, and where the project can recover after a failed build usually become visible only in the next round.</p><p>That is why I do not find a single ranking from first to twelfth useful. Replit, Lovable, Bolt, v0, Base44, and Google AI Studio are strongest when the job is to turn an idea into a running first version. Codex, Claude Code, Cursor, Windsurf, the GitHub Copilot app, and Google Antigravity make more sense when a project already exists and its files, commands, checks, and diffs need to be reviewed. The groups overlap, but their starting points remain different.</p><p>The question I want to answer is not “Which tool is best?” It is “At this stage of the project, which kind of workflow would I choose, and what evidence would I need before continuing?”</p><h4>Two kinds of tools</h4><p>I divide the products by their starting workflow, not by a permanent label attached to each brand.</p><p>An <strong>AI app builder</strong> combines a prompt, project setup, live preview, and usually hosting. It is a practical starting point when no project exists and the first need is a runnable user path with little setup.</p><p>An <strong>AI coding agent</strong> works more directly with project files, commands, tests, and version-control changes. It becomes more useful when a project already exists and the next decision depends on inspecting or changing that project within a controlled scope.</p><p>An inline code assistant is a third mode, but it is outside this comparison. Inline completion is valuable when someone is already writing code; it does not provide the same end-to-end path as a builder or project agent.</p><p>These modes are not levels in a progression from weak to strong. When an agent can touch more files and tools, I also have more to review. I usually start a bounded prototype with a builder and move to an agent only when the next task genuinely needs file-level control. <a href="https://ailesson.io/courses/vibe-coding-for-beginners">AILesson’s Vibe Coding for Beginners Course</a> begins with the same distinction rather than prescribing a brand.</p><h4>How I compared them</h4><p>I used two evidence layers, checked on August 20, 2026.</p><ul><li><strong>Product-documented behavior</strong> comes from current official documentation, support pages, and release notes. It explains the workflow a product offers, but does not prove that the product completed our task.</li><li><strong>Observed project evidence</strong> comes from a preserved build, test, change, or handoff record. It supports only the behavior that was actually checked.</li></ul><p>Only the Replit-to-Codex path can be traced through the preserved Community Book Swap Checklist project used in the AILesson Course. For the other ten products, I reviewed current official workflows; I do not present documentation review as if I completed the same hands-on test in every product. A feature page can establish Git sync, checkpoints, or browser testing, but not that one tool would complete the brief better than another.</p><p>The observed project began with a bounded brief: build a mobile-first checklist with categories, completion state, filters, refresh persistence, a recoverable reset, and no real personal data. Its later coding-agent task was deliberately smaller: inspect one file-level dependency conflict, propose a bounded change, and preserve the existing application behavior.</p><p>The project record separates passed, partially passed, failed, and untested requirements. I will not turn one variable model run into a permanent quality ranking. I use it to set the comparison standard: running behavior, actual file changes, command output, recovery path, handoff state, and publishing boundary.</p><h4>My shortlist</h4><ul><li><strong>Start with Replit</strong> when you want one workspace for planning, building, Preview, checkpoints, files, and publishing — and you are prepared to test the result inside that workspace.</li><li><strong>Start with Lovable or v0</strong> when visual iteration is the main uncertainty and a Git-backed handoff matters.</li><li><strong>Start with Bolt</strong> when the priority is a browser-based web build with immediate execution, code access, version history, and GitHub as an exit path.</li><li><strong>Start with Base44</strong> when built-in data, authentication, permissions, and hosting remove more work than platform dependence creates.</li><li><strong>Start with Google AI Studio</strong> when Gemini capabilities, native Android generation, or Cloud Run deployment is central to the product rather than an incidental integration.</li><li><strong>Start with a coding agent</strong> — Codex, Claude Code, Cursor, Windsurf, the GitHub Copilot app, or Google Antigravity — when a repository already exists and the next result must be a reviewable, testable change.</li></ul><p>This is a starting shortlist, not a set of permanent lanes. Builders are adding repositories and editors; coding agents are operating browsers and producing visual evidence. I would still choose around the project’s next unresolved problem, not stay loyal to a category.</p><h4>App builders</h4><p>If I have a bounded idea but no project, these are the six products I would inspect first. All reduce setup. What separates them is where the code lives, who owns the backend, how visual changes return to source, and what remains when the project leaves the platform.</p><ul><li><strong>Replit Agent</strong></li><li><strong>Best starting fit:</strong> A complete first app path in one workspace</li><li><strong>Control and handoff:</strong> Files, Shell, checkpoints, Git, export, and publishing</li><li><strong>Main watchpoint:</strong> Preview success is not proof of a reproducible export</li><li><strong>Lovable</strong></li><li><strong>Best starting fit:</strong> Full-stack web apps with frequent visual refinement</li><li><strong>Control and handoff:</strong> Source-connected visual edits and two-way GitHub sync</li><li><strong>Main watchpoint:</strong> Managed services still need a portability check</li><li><strong>Bolt</strong></li><li><strong>Best starting fit:</strong> Fast browser-based web and JavaScript projects</li><li><strong>Control and handoff:</strong> Code view, version history, branches, and GitHub sync</li><li><strong>Main watchpoint:</strong> Token use grows with project size and iteration</li><li><strong>v0</strong></li><li><strong>Best starting fit:</strong> Design-led apps in the React and Vercel ecosystem</li><li><strong>Control and handoff:</strong> Full editor, production-like Preview, commits, and PRs</li><li><strong>Main watchpoint:</strong> A strong first UI still needs behavioral testing</li><li><strong>Base44</strong></li><li><strong>Best starting fit:</strong> Apps that need data, login, permissions, and hosting</li><li><strong>Control and handoff:</strong> Code view; ZIP and GitHub export on eligible plans</li><li><strong>Main watchpoint:</strong> More of the stack begins inside the platform</li><li><strong>Google AI Studio Build</strong></li><li><strong>Best starting fit:</strong> Gemini-first web or native Android apps</li><li><strong>Control and handoff:</strong> Live code editing, ZIP/GitHub export, Cloud Run deployment</li><li><strong>Main watchpoint:</strong> Data services and usage costs need separate checks</li></ul><h4>Replit: everything in one workspace</h4><p>Replit began as a browser-based coding environment and grew into a full-stack software-creation platform. <a href="https://replit.com/blog/introducing-replit-agent">Replit Agent</a>, introduced in 2024, added natural-language app creation and deployment. I put Replit first among the builders not because it wins every feature, but because it keeps building, running, and recovery evidence close together — and because it is the only builder here backed by a complete observed project record.</p><p><a href="https://docs.replit.com/learn/build-with-agent">Replit Agent documentation</a> describes planning, building, testing, and checkpoints in the same workspace. That integration matters for beginners because a failed requirement can be checked against the running Preview, project files, Shell, and an earlier checkpoint without immediately moving the project elsewhere.</p><p>Agent can begin in Plan mode, then write across files, install dependencies, debug failures, and improve the app. Screenshots, files, and Canvas notes can supply visual or business context that a prompt does not express well. Replit also brings databases, authentication, Secrets, Git, and Deployments into the workspace, so a project can move from an empty starting point to a published app with persistent data without first assembling a local toolchain. Its checkpoints can cover code, Agent context, tasks, and connected database state rather than only a text diff.</p><figure><img alt="Replit Agent conversation beside a running app Preview during an official first-app walkthrough" src="https://cdn-images-1.medium.com/proxy/0*UlCULKAFGg7VI75a.webp" /></figure><p><em>Replit’s official first-app documentation, accessed August 20, 2026. The screenshot identifies the Agent-and-Preview workspace; it does not establish that a generated app passed its requirements.</em></p><p>The Course run also exposed the limit of that convenience. A polished Preview did not prove a “no hidden external dependency” requirement. A file scan found unused Google Fonts links, and the focused export later proved reviewable but not independently buildable because workspace-level dependency information was missing. Replit was still useful; the evidence simply stopped short of reproducibility.</p><p>If I need to get one user path running quickly and am willing to test inside the workspace, I would start with Replit. I would not treat “Download source” as proof of reproducibility, however. Exporting files and rebuilding the same state on another machine are separate checks.</p><h4>Lovable: visual editing with a managed backend</h4><p><a href="https://lovable.dev/gpt-engineer">Lovable grew out of the open-source </a><a href="https://lovable.dev/gpt-engineer">gpt-engineer project</a> and its former commercial web product, GPT Engineer. It is now a natural-language full-stack web platform for non-technical builders and software teams. When my main uncertainty is “How many times will this interface change?” rather than “How should I design the architecture?”, Lovable makes my first shortlist.</p><p>Lovable keeps visual editing, full-stack services, and source handoff on one path. <a href="https://lovable.dev/blog/visual-edits">Visual Edits</a> lets a user select an element in the running interface, adjust copy, color, and spacing, and write the result back to source. When the app needs dynamic data, Lovable Cloud provides a PostgreSQL database, authentication, Storage, Realtime, and Edge Functions; Supabase remains another supported route. Authenticated external APIs use Secrets and server-side functions instead of exposing credentials in the browser.</p><p>Its distinctive combination is visual selection plus two-way GitHub sync: a visual change does not remain an isolated mockup, and the code can enter a conventional branch and collaboration workflow. Publishing creates an explicit snapshot, so later editor changes do not silently replace the live version. Eligible Cloud projects can also separate Test and Live data and configuration.</p><figure><img alt="Lovable Visual Edits panel beside a selected element in the running app" src="https://cdn-images-1.medium.com/proxy/0*K_N5jlvi-Fol04m6.webp" /></figure><p><em>Official Lovable Visual Edits article, March 13, 2025. It shows the visual editing surface, not the quality or portability of the resulting code.</em></p><p>New Lovable apps created since May 13, 2026 use TanStack Start with server-side rendering; older apps remain React and Vite projects, with different hosting requirements. I would keep Lovable for web apps with frequent visual change and an early need for login or data. If easy migration is a hard requirement, I would not stop after finding code in GitHub; I would trace how the database, users, files, and Secrets move as well.</p><h4>v0: from interface generation to full projects</h4><p><a href="https://v0.app/docs">v0 is Vercel’s AI development agent</a>, originally known for generating React interfaces and components. It has since expanded into full-stack project work while retaining a design-first connection to Vercel. I would compare it directly with Lovable: both suit visual iteration, while v0’s strongest path runs through React, GitHub, and Vercel.</p><p>v0 can turn text, wireframes, or screenshots into high-fidelity interfaces, then work on frontend code, API routes, and database integrations in a full VS Code-style editor. <a href="https://v0.app/docs/design-mode">Design Mode</a> lets a user select an element in the real Preview and adjust it with controls or natural-language instructions. Applying the edit creates a new project version, so the resulting source can be diffed, reverted, or refined.</p><p>Its Vercel and GitHub workflow is the defining feature. A Project shares deployments, domains, environment variables, and integrations across multiple chats. Once GitHub is connected, each chat works on a dedicated branch, code-changing messages create commits automatically, and the result enters main through a pull request rather than a direct push. Database integrations include Neon, Supabase, and Upstash.</p><figure><img alt="The Design Mode control in the v0 prompt bar" src="https://cdn-images-1.medium.com/proxy/0*LBwWKp8dQw9P7mQP.webp" /></figure><p><em>Official v0 documentation, accessed August 20, 2026. This cropped screenshot locates Design Mode; use the resulting project diff — not the control itself — to judge the change.</em></p><p>When React and Vercel are already decided and the project depends on a landing page, dashboard, or precise UI, I would rank v0 highly. The same integration defines its boundary: an unusually direct Vercel deployment does not prove that another host needs no adjustment. I would still test forms, permissions, data, and failure states after the first screen looks right.</p><h4>Bolt: the browser is the JavaScript runtime</h4><p><a href="https://blog.stackblitz.com/posts/bolt-100k-oss-fund/">Bolt.new is StackBlitz’s AI app builder</a>. It builds on WebContainers, a WebAssembly environment that runs a Node.js toolchain inside the browser instead of streaming a remote development machine. That is why Bolt deserves its own slot: the promise is not merely generated code, but code that can install, start, and fail visibly in the browser.</p><p><a href="https://support.bolt.new/get-started/quickstart">Bolt’s quickstart</a> places the prompt, code editor, browser runtime, and Preview in one path. Its central feature is the in-browser development runtime: the agent can create files, install npm packages, start a Node.js service, observe runtime failures, and continue fixing them without a local project setup. If the initial prompt explicitly requests a mobile app, Bolt can also produce an Expo-compatible project.</p><p>Bolt Cloud adds an automatically provisioned database, user authentication, Secrets, Edge Functions, and hosting, including a shareable bolt.host address. A database can also be claimed and managed through Supabase. Code View, version history, and the <a href="https://support.bolt.new/integrations/git">GitHub integration</a> expose the implementation and provide a handoff path.</p><figure><img alt="Bolt start screen with a natural-language app request in the prompt box" src="https://cdn-images-1.medium.com/proxy/0*sNumkYLGaqVIEbZO.webp" /></figure><p><em>Official Bolt quickstart, accessed August 20, 2026. It shows the prompt-led starting point, not a completed task result.</em></p><p>I would use Bolt for a JavaScript or Node.js prototype when “run it now” matters more than merely receiving source. I would not treat it as a cloud IDE for arbitrary backend languages: PHP and Python are outside the documented runtime, and repeated iterations keep consuming tokens. I would settle the stack and budget before starting.</p><h4>Base44: the backend is already there</h4><p><a href="https://base44.com/about-us">Base44 is a natural-language app builder now operated by Wix</a>. It resembles an integrated business-app platform more than a design-only generator: data, identity, backend logic, and hosting are present by default. I would reach for it when evaluating a CRM, internal tool, or membership app — not for a static landing page.</p><p><a href="https://docs.base44.com/Getting-Started/Quick-start-guide">Base44’s quickstart</a> also begins with a prompt and live Preview, but its center of gravity is a ready-made backend for business applications. Its NoSQL database represents models as entities and supports realtime subscriptions plus row- and field-level permissions. Authentication covers email/password, common social providers, and SSO. Custom backend logic runs as Deno and TypeScript serverless functions.</p><p>Base44 divides integrations into several layers. Built-in actions generate text or images, send email, and process files; connectors use OAuth for accounts such as Google Workspace or Slack; custom integrations can be generated from an OpenAPI description and proxied through the backend so browser code never receives the credential. CRM tools, internal applications, member systems, and workflow-heavy apps make better use of these features than a static marketing page.</p><figure><img alt="Base44 AI chat beside a live app Preview in the builder" src="https://cdn-images-1.medium.com/proxy/0*tM4GIAmvu-f31_wt.webp" /></figure><p><em>Official Base44 documentation, accessed August 20, 2026. The screenshot shows the chat-and-Preview layout; integrated services and export still require separate checks.</em></p><p>Its <a href="https://docs.base44.com/documentation/building-your-app/developer-tools">developer tools</a> include a React/Vite code view, API Activity Monitor, GitHub workflow, ZIP export, and local-development path; built-in hosting supplies HTTPS and custom domains. I would inspect what “export” means here: moving the frontend and functions does not automatically move the database, authentication, integrations, or Base44 SDK. I would consider Base44 when the team accepts platform dependence in exchange for less setup, not when complete self-hosting is the first constraint.</p><h4>Google AI Studio: when Gemini is the product</h4><p><a href="https://ai.google.dev/gemini-api/docs/aistudio-build-mode">Google AI Studio</a> began as Google’s browser environment for experimenting with Gemini prompts. Build mode has expanded it into web and native Android development. I would not make it a general default simply because it can now build apps; its integration becomes distinctive when Gemini, native Android, or Cloud Run is already central to the product.</p><p><a href="https://ai.google.dev/gemini-api/docs/aistudio-build-mode">Google’s current Build documentation</a> makes AI Studio more than a playground for Gemini prompts. Web mode creates a React frontend and Node.js server runtime, supports npm packages and network-accessible databases, and places the Gemini API key in server-side Secrets. The Antigravity Agent manages changes across project files and verifies updates. A project can move to GitHub or a ZIP archive, or deploy directly to Cloud Run.</p><p>Android mode generates a native Kotlin and Jetpack Compose project with an in-browser emulator, physical-device installation, and a Play testing path. That is a meaningful distinction from most web-first builders. Android projects are currently client-side, however, so the server runtime and Secrets available to web apps do not transfer automatically.</p><figure><img alt="Google AI Studio Build screen for choosing Gemini-powered app capabilities" src="https://cdn-images-1.medium.com/proxy/0*Twooc2sdwJrZjkYE.webp" /></figure><p><em>Official Google AI Studio product image from October 2025. It shows the Build entry surface; the surrounding capability claims were rechecked on August 20, 2026.</em></p><p>I would seriously consider this route when Gemini text, image, or Live API behavior is the app itself, or when native Android and Cloud Run are explicit targets. A shared AI Studio app lets authorized recipients view and fork its code, their Gemini calls consume the creator’s quota, and databases remain external services. I would verify “Gemini was easy to add” separately from “data, cost, and handoff are clear.”</p><h4>When I switch to an agent</h4><p>I would not move a project to a more technical-looking agent simply because two prompts failed. A tool change should resolve a specific control problem; otherwise it only moves the same vague request into a different input box.</p><p>In the Course project, the reason to move was concrete: the visible app could not settle a file-level dependency question. The working state was preserved, the relevant files were exported, and Codex was asked to inspect before editing. It proposed deleting exactly three unused font-related lines, while leaving application behavior and every other file outside the approved scope.</p><p>That Replit-to-Codex sequence is covered step by step in <a href="https://ailesson.io/courses/vibe-coding-for-beginners">Vibe Coding for Beginners</a>. Its value here is not promotional proof that those two brands win the comparison. It provides a real example of the threshold: switch tools when the next claim requires a different kind of evidence and control.</p><h4>Coding agents</h4><p>Once a repository exists, I expect more from an agent. “Task complete” carries little information. I want to see the plan, permission boundary, changed files, diff, command results, behavioral retest, and recovery path.</p><ul><li><strong>Codex</strong></li><li><strong>Best starting fit:</strong> Bounded or multi-step work in an existing local project</li><li><strong>Review and recovery surface:</strong> Plans, commands, checks, changed files, and diff review</li><li><strong>Main watchpoint:</strong> Broad permissions require an explicit scope</li><li><strong>Claude Code</strong></li><li><strong>Best starting fit:</strong> Terminal-first repository work</li><li><strong>Review and recovery surface:</strong> Plan mode, permission modes, commands, tests, and Git</li><li><strong>Main watchpoint:</strong> The operator must be comfortable reading command output</li><li><strong>Cursor Agent</strong></li><li><strong>Best starting fit:</strong> Agent work alongside everyday editor navigation</li><li><strong>Review and recovery surface:</strong> File-by-file diff review, selective acceptance, checkpoints</li><li><strong>Main watchpoint:</strong> Checkpoints cover Agent edits, not permanent history</li><li><strong>Windsurf Cascade</strong></li><li><strong>Best starting fit:</strong> Editor-local work plus Windsurf 2.0 agent orchestration</li><li><strong>Review and recovery surface:</strong> Plans, tool calls, diagnostics, checkpoints, and reverts</li><li><strong>Main watchpoint:</strong> The product surface now spans Cascade and Devin</li><li><strong>GitHub Copilot app</strong></li><li><strong>Best starting fit:</strong> Parallel local or cloud sessions around repositories</li><li><strong>Review and recovery surface:</strong> Interactive/Plan/Autopilot modes and isolated workspaces</li><li><strong>Main watchpoint:</strong> Autonomy, isolation, and billing vary by run mode</li><li><strong>Google Antigravity</strong></li><li><strong>Best starting fit:</strong> Work that benefits from plans and visual proof</li><li><strong>Review and recovery surface:</strong> Reviewable artifacts, diffs, screenshots, and recordings</li><li><strong>Main watchpoint:</strong> More artifacts help only when tied to requirements</li></ul><h4>Codex: work organized around reviewable changes</h4><p><a href="https://developers.openai.com/codex/">Codex is OpenAI’s coding agent</a>, designed to understand codebases, build and test features, fix bugs, and review changes. It is available across desktop, CLI, IDE, and cloud surfaces rather than being tied to one editor. In this comparison, I care less about the number of entry points than about keeping task scope, commands, and the final diff in one review chain.</p><p>The Codex workflow centers on editing files, running commands and checks, and reviewing the resulting diff. A local environment can work directly on the current working tree, a Git worktree can isolate parallel changes, and a cloud environment can hand a task to a remote sandbox. The integrated terminal and Review surface keep command output, changed files, and line-level diffs attached to one task.</p><p>Repository conventions and repeated procedures can be encoded in AGENTS.md, Skills, and Plugins so lint, test, documentation, or release rules do not need to be restated in every prompt. Permissions and sandbox settings govern which files, networks, and external tools the agent can reach. As that extension surface grows, the requested goal, protected areas, and acceptance commands need to become more explicit.</p><figure><img alt="Codex desktop with a bounded change request and a Review pane showing three deleted Google Fonts lines" src="https://cdn-images-1.medium.com/proxy/0*Flx9alEbDTgWHmiP.webp" /></figure><p><em>Course-prepared Codex desktop demonstration reconstructed from the preserved project and exact three-line diff. It shows the recorded review action, not the original execution screen.</em></p><p>In the Course record, what I could verify was not “the project is fixed,” but a bounded three-line deletion compared with the preserved original. I would consider Codex for a bug fix, refactor, test, review, or verifiable multi-step task in an existing repository. With only a product idea and no project structure, I would start with a builder instead.</p><h4>Claude Code: terminal-first and highly extensible</h4><p><a href="https://code.claude.com/docs/en/how-claude-code-works">Claude Code is Anthropic’s agentic coding environment</a>. It began in the terminal, with a harness that supplies project context, tools, permissions, and an execution loop, and now also spans desktop, IDE, web, and automation. If I already read shell commands and Git diffs comfortably and want to wire my own engineering rules into the agent loop, it feels more natural than a fixed builder interface.</p><p>Claude Code includes tools for file operations, code search, shell commands, Git, web lookup, and code diagnostics. Its loop gathers context, acts, and verifies. Plan mode limits exploration to read-only tools; Default and Auto-accept modes adjust which edits and commands require approval. A checkpoint taken before each file edit can be restored with double Esc or /rewind, but remote database, deployment, and API side effects are outside that recovery mechanism.</p><p>The product is more than a terminal chat pane. CLAUDE.md carries persistent project conventions, Skills package on-demand workflows, MCP connects external services, Hooks run deterministic scripts around tool and session events, and Subagents or Agent Teams move work into separate contexts. This is useful for teams already comfortable with CLI workflows and interested in wiring engineering rules into the agent loop. Each extension also adds context, permission, or maintenance overhead.</p><figure><img alt="Claude Code terminal showing a project prompt and recent file activity" src="https://cdn-images-1.medium.com/proxy/0*HWk1XVa7OEg7NElx.webp" /></figure><p><em>Official Anthropic product screenshot, accessed August 20, 2026. It identifies the terminal workflow; it does not verify a particular repository change.</em></p><p>I would not discount Claude Code because the terminal lacks a permanent visual Preview, or overrate it because the interface looks technical. The workflow works for me only if I can read proposed commands, inspect the Git diff, and distinguish local checkpoints from durable version history.</p><h4>Cursor: a gradual path from completion to agents</h4><p><a href="https://cursor.com/blog/series-b">Cursor is an AI-first code editor created by Anysphere</a>. It began with codebase-aware chat, completion, and editing, then expanded toward foreground and cloud agents. Its most useful distinction is not simply that it “has an agent,” but that I can raise the autonomy level gradually — from completion to a focused edit to a larger delegated task.</p><p><a href="https://docs.cursor.com/en/get-started/quickstart">Cursor’s current workflow</a> covers three different scales of assistance. Tab predicts multi-line and cross-file completions, Inline Edit changes selected code, and <a href="https://docs.cursor.com/chat/overview">Agent</a> searches the codebase, edits multiple files, runs terminal commands, and fixes errors. Ask mode is read-only, Manual mode only edits explicitly selected files, and Custom modes combine selected tools with specialized instructions. A developer does not have to start a high-autonomy task for every small change.</p><p>Review Diffs supports file-by-file inspection, Rules preserve project conventions, and MCP connects external tools. <a href="https://docs.cursor.com/en/agent/chat/checkpoints">Checkpoints</a> automatically save Agent-made file changes. For work away from the local machine, Background Agents clone a GitHub repository into an isolated Ubuntu environment, install dependencies, run tests, and push a separate branch; web, mobile, and Slack surfaces can start or follow those runs.</p><figure><img alt="Cursor Agent workspace with a conversation, changed files, and code review panes" src="https://cdn-images-1.medium.com/proxy/0*cYpNi2knGxkUK4SU.webp" /></figure><p><em>Official Cursor documentation image, accessed August 20, 2026. It shows the Agent review surface, not whether the displayed change is correct.</em></p><p>If I already read and change code in an editor and want to move gradually between completion and agent work, Cursor is a natural fit. Its local checkpoints cover only Agent changes, omit manual edits, and are cleaned up automatically, so I would not substitute them for Git. Because background environments have internet access and auto-run commands, I would review repository permissions, Secrets, and prompt-injection exposure separately.</p><h4>Windsurf: the two-layer Cascade and Devin workflow</h4><p><a href="https://windsurf.com/switch/cursor">Windsurf is Cognition’s agentic IDE</a>, developed alongside the company’s autonomous cloud agent, Devin. This explains its two-layer design: synchronous work with Cascade inside the editor, plus longer tasks delegated to cloud agents. That orchestration is attractive when I need to watch several tasks, but potentially excessive for one small repository change.</p><p><a href="https://windsurf.com/switch/cursor">Windsurf 2.0</a> still begins with the editor. Cascade sits beside the codebase, plans tasks, searches and edits files, calls tools, reads diagnostics, and uses checkpoints and reverts when a change goes wrong. The editor offers models from several providers. Code Maps visualize relationships across files and symbols, while Preview lets web changes run in the same environment where they were made.</p><p>The defining 2.0 addition is Agent Command Center. Its Kanban view collects local and cloud agents, while Spaces organize sessions, pull requests, files, and context by project. A plan made with a local agent can be handed to Devin, which continues in its own VM with a desktop, browser, and terminal. Windsurf therefore serves both immediate editor pairing and longer background work instead of being only a chat panel beside code.</p><figure><img alt="Windsurf editor with the Cascade panel open beside a project workspace" src="https://cdn-images-1.medium.com/proxy/0*2OASaymESYIyTAyP.webp" /></figure><p><em>Official Cascade documentation image, accessed August 20, 2026. It locates the agent inside the editor; the current Windsurf 2.0 surface also includes broader Devin integration.</em></p><p>The local-Cascade and cloud-Devin combination is attractive when I need to move several tasks at once, but it also makes permissions and billing harder to read at a glance. Local editing, remote execution, model choice, and usage limits may not follow one set of rules. I would check checkpoint scope before restoring and confirm repository, network, and credential boundaries before a cloud handoff.</p><h4>GitHub Copilot app: sessions inside the GitHub workflow</h4><p>GitHub Copilot first became familiar as code completion inside an editor. The standalone <a href="https://github.blog/changelog/2026-06-17-github-copilot-app-generally-available/">GitHub Copilot app became generally available in June 2026</a>, shifting the unit of work from a suggestion to a branch, issue, or pull request. I see its clearest audience not as every GitHub user, but as teams already organized around issues and PRs that now want several sessions running in parallel.</p><p>Each session can run in its own Git worktree, the current local repository, or a GitHub-hosted cloud sandbox, with a dedicated branch. Several tasks can progress without competing for one working tree, and an issue can move directly into implementation, diff review, commit, and pull-request work.</p><p>Interactive mode pauses for collaboration, Plan mode presents a plan for approval, and Autopilot can write code, run tests, and iterate without waiting. Each session can use a different model and reasoning effort; Auto selects a model based on the task, and external providers can be added with the user’s own API key. An integrated terminal, browser tools, Quick Chat, and session history support execution and review.</p><figure><img alt="GitHub Copilot app with agent sessions, task progress, and a project workspace" src="https://cdn-images-1.medium.com/proxy/0*Y8IKhJXGrz1s2wuT.webp" /></figure><p><em>Official GitHub announcement, June 17, 2026. It shows the standalone Copilot app, rather than inline completion in an editor.</em></p><p>If the code is already on GitHub and everyday work revolves around issues and pull requests, I would test the Copilot app early. Local worktrees, direct local folders, and cloud sandboxes still have different isolation, resource access, and cost boundaries. Autopilot can proceed without waiting; I would still perform the final review.</p><h4>Google Antigravity: plans and screenshots as review artifacts</h4><p><a href="https://developers.googleblog.com/en/build-with-google-antigravity-our-new-agentic-development-platform/">Google introduced Antigravity in November 2025</a> as an agent-first platform spanning the editor, terminal, and browser. Antigravity 2.0 added a standalone command center while retaining IDE, CLI, and SDK surfaces. It makes my shortlist not because it has many entry points, but because plans, diffs, screenshots, and recordings become commentable deliverables.</p><p>The standalone app centrally launches and monitors multiple local agents and scheduled tasks; Antigravity IDE lets agents use the editor, terminal, and browser. The distinctive comparison point is not the number of entry points but the way artifacts become part of the control loop.</p><p>Before coding, an agent can create an Implementation Plan and Task List that accept document-style comments. During implementation it produces code diffs, and after completion a Walkthrough describes the changes and tests. A browser subagent can click through the app and attach screenshots or a recording. Google’s <a href="https://codelabs.developers.google.com/getting-started-google-antigravity">official Codelab</a> also shows point-in-time Undo and the ability to send an IDE diagnostic or selected terminal failure to the agent.</p><figure><img alt="Google Antigravity conversation presenting an Implementation Plan and a Proceed control" src="https://cdn-images-1.medium.com/proxy/0*G-GG4AxWa5qrQDjT.webp" /></figure><p><em>Official Google Antigravity Codelab, accessed August 20, 2026. It shows a plan awaiting review; it does not prove the later implementation matched that plan.</em></p><p>I would shortlist Antigravity when UI behavior must be verified in a browser or when I want plan and visual evidence beside the source change. More artifacts do not automatically mean stronger proof, and some policies let an agent continue without waiting for Proceed. I would still map the plan, diff, screenshot, and recording back to the brief one by one.</p><h4>What the price hides</h4><p>I left monthly prices out of the main tables because they create false comparability. The products meter subscription access, messages, credits, tokens, model usage, compute, deployments, or some combination. A low advertised monthly price can still produce an interrupted run; a higher plan may include model or compute credit that another product bills separately.</p><p>Before choosing a plan, compare three facts instead of a single advertised monthly price:</p><ol><li>the lowest plan that includes the workflow you need, such as full builds, Git export, background agents, or cloud sandboxes;</li><li>the unit that is actually metered — tokens, credits, messages, model calls, compute, or agent effort; and</li><li>separate hosting, database, model, or deployment charges that continue after generation.</li></ol><p>Check the official pricing and checkout surface immediately before paying. A fair cost test records spend for your own bounded task; it does not assume that a plan with the lowest headline price will finish it.</p><h4>Two tools I left out</h4><p>I did not retain historically prominent tools after they lost their new-user path. Firebase Studio disabled new workspace creation and user signup on June 22, 2026, ahead of its March 22, 2027 shutdown, and directs new work toward Google AI Studio or Antigravity. <a href="https://firebase.google.com/docs/studio/migrating-project">Firebase’s migration documentation</a> makes it unsuitable as a new-user recommendation.</p><p>GitHub Spark also stopped accepting new users and new applications in August 2026. <a href="https://docs.github.com/en/copilot/concepts/spark">GitHub’s current Spark documentation</a> tells existing users to export their work. Both products may still matter in a history of the category, but neither should occupy a main comparison slot for someone choosing a tool now.</p><h4>How I would choose</h4><ul><li><strong>You have a bounded idea but no project</strong></li><li><strong>Start by testing:</strong> Replit, Lovable, Bolt, v0, Base44, or Google AI Studio</li><li><strong>Why:</strong> The immediate question is whether you can obtain and test a complete running path with little setup.</li><li><strong>The interface needs frequent visual refinement</strong></li><li><strong>Start by testing:</strong> Lovable, v0, or Bolt</li><li><strong>Why:</strong> Each offers a visual selection or design surface connected to the running project.</li><li><strong>The app depends on integrated data, authentication, or hosting</strong></li><li><strong>Start by testing:</strong> Base44, Replit, Lovable, or Bolt</li><li><strong>Why:</strong> Integration may remove setup, but portability and public-access boundaries need explicit checks.</li><li><strong>A repository already exists and the change is narrow</strong></li><li><strong>Start by testing:</strong> Codex, Claude Code, Cursor, Windsurf, Copilot, or Antigravity</li><li><strong>Why:</strong> The useful output is a scoped plan, reviewable change, checks, and a recovery path.</li><li><strong>You prefer terminal work and can review commands</strong></li><li><strong>Start by testing:</strong> Claude Code or Codex CLI</li><li><strong>Why:</strong> The terminal can make project actions direct, but the operator owns the permission and command boundary.</li><li><strong>You need visual artifacts of plans and browser verification</strong></li><li><strong>Start by testing:</strong> Antigravity, or another agent with equivalent recorded evidence</li><li><strong>Why:</strong> Plans, screenshots, and recordings can make review easier when they correspond to the actual requirement.</li></ul><p>I would not declare an overall winner from this table. The same product can be sensible in one row and needless complexity in another. For a first project, I would shortlist two products from the same row, confirm that the needed feature is included in the current plan, and build one complete user path in each before expanding the scope.</p><p>If you want to practise that process before committing a real project, the <a href="https://ailesson.io/courses/vibe-coding-for-beginners">AILesson Vibe Coding for Beginners Course</a> follows one synthetic app from brief to Preview, focused repair, file inspection, bounded agent change, verification, and an honest non-public handoff. It stops where the evidence stops: the resulting demo is not described as production-ready, independently reproducible, or publicly deployed.</p><p>Whichever tool you choose, keep the same acceptance rule. A polished screen is a candidate result. Trust grows only when the behavior, changes, checks, recovery path, and handoff state are visible enough for you — or the next person — to inspect.</p><h4>References</h4><ul><li><a href="https://docs.replit.com/learn/build-with-agent">Replit Agent documentation</a> — planning, testing, checkpoints, and the integrated workspace.</li><li><a href="https://docs.lovable.dev/tips-tricks/deployment-hosting-ownership">Lovable deployment and ownership documentation</a> — managed services, GitHub code ownership, hosting, and migration boundaries.</li><li><a href="https://support.bolt.new/building/intro-bolt">Bolt introduction</a> — browser-based building, databases, authentication, and hosting.</li><li><a href="https://v0.app/docs/faqs">v0 FAQs</a> — the 2026 editor, Git integration, projects, and Preview changes.</li><li><a href="https://docs.base44.com/documentation/building-your-app/developer-tools">Base44 developer tools</a> — code access, backend services, integrations, GitHub, and local development.</li><li><a href="https://ai.google.dev/gemini-api/docs/aistudio-build-mode">Google AI Studio Build documentation</a> — current web and Android Build modes, export, and deployment paths.</li><li><a href="https://developers.openai.com/codex/">Codex documentation</a> — project understanding, changes, commands, checks, and review.</li><li><a href="https://code.claude.com/docs/en/how-claude-code-works">How Claude Code works</a> — built-in tools, Plan mode, permissions, and checkpoints.</li><li><a href="https://docs.cursor.com/chat/overview">Cursor Agent documentation</a> — completion, Agent tools, project context, and review workflow.</li><li><a href="https://windsurf.com/switch/cursor">Windsurf 2.0</a> and <a href="https://docs.devin.ai/desktop/cascade/cascade">Cascade documentation</a> — the current editor, agent orchestration, planning, tools, checkpoints, and diagnostics.</li><li><a href="https://docs.github.com/en/copilot/how-tos/github-copilot-app/agent-sessions">GitHub Copilot app sessions</a> — session modes, models, branches, and isolated workspaces.</li><li><a href="https://codelabs.developers.google.com/getting-started-google-antigravity">Google Antigravity Codelab</a> — product surfaces, browser actions, schedules, and artifact-led work.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ad583a2d379" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Best Online Linux Terminals in 2026: Real Environments Compared]]></title>
            <link>https://labexio.medium.com/best-online-linux-terminals-in-2026-real-environments-compared-4838b4258bc7?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/4838b4258bc7</guid>
            <category><![CDATA[articles]]></category>
            <category><![CDATA[labex]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 06:28:35 GMT</pubDate>
            <atom:updated>2026-08-19T06:28:35.414Z</atom:updated>
            <content:encoded><![CDATA[<p>Running ls in a browser does not prove that Linux is running behind the prompt.</p><p>Some online terminals connect to an Ubuntu virtual machine. Some start a short-lived container. Others implement familiar commands in JavaScript without a Linux kernel, package database, service manager, or real process table. All three can draw a convincing prompt; only the first two execute commands on Linux.</p><p>That difference determines what you can practise. A command simulator may be enough to learn what cd does. Installing packages, managing users, inspecting processes, starting services, and diagnosing a changed system require a real Linux environment.</p><p>For learning Linux rather than administering a particular cloud account, <a href="https://labex.io/tutorials/linux-online-linux-terminal-and-playground-372915"><strong>LabEx Online Linux Terminal</strong></a><strong> is the strongest option in this comparison</strong>. It provides an Ubuntu VM with sudo, several interfaces around the same system, guided labs, state checks, challenges, and contextual help. The terminal is also one entry point into a broader sandbox catalog and native LabEx apps for iPhone and Mac. Google Cloud Shell, AWS CloudShell, Azure Cloud Shell, GitHub Codespaces, and CoCalc are useful real environments built for different jobs. Coddy and WebTerm show why “runs in a browser” is not a sufficiently precise category.</p><h4>What is actually running behind the prompt?</h4><ul><li><strong>Command simulator</strong></li><li><strong>What runs:</strong> Selected commands and a virtual file tree implemented in browser code</li><li><strong>Practical consequence:</strong> Useful for syntax practice, but there is no Linux kernel or arbitrary system software</li><li><strong>Example:</strong> WebTerm</li><li><strong>Stateless Linux runner</strong></li><li><strong>What runs:</strong> A fresh server-side Linux container for each submission</li><li><strong>Practical consequence:</strong> Real Bash output, but files and directory changes disappear between runs</li><li><strong>Example:</strong> Coddy</li><li><strong>Stateful hosted Linux</strong></li><li><strong>What runs:</strong> A remote Linux userspace retained for a session or project</li><li><strong>Practical consequence:</strong> Real files, processes, and packages within the service’s permissions</li><li><strong>Example:</strong> AWS CloudShell, Azure Cloud Shell, CoCalc</li><li><strong>Virtual machine</strong></li><li><strong>What runs:</strong> A complete Linux guest operating system provisioned on a server</li><li><strong>Practical consequence:</strong> Suitable for users, permissions, packages, processes, services, and networking</li><li><strong>Example:</strong> LabEx, Google Cloud Shell</li><li><strong>Dev container on a VM</strong></li><li><strong>What runs:</strong> A project-specific container backed by a hosted VM</li><li><strong>Practical consequence:</strong> A repeatable development workspace tied to repository files and tools</li><li><strong>Example:</strong> GitHub Codespaces</li></ul><p>A real system gives diagnostic commands real state to inspect:</p><pre>uname -a<br>cat /etc/os-release<br>id<br>ps aux<br>ip addr</pre><p>A simulator can return prepared text for some of these commands. It cannot expose an arbitrary package, daemon, kernel interface, or distribution-specific configuration that its developers did not implement.</p><h4>Online Linux terminal comparison</h4><p>The table focuses on the details that change what a learner can do. Startup speed is not scored because it varies with region, browser state, service capacity, and whether a remote environment is already warm. Product behaviour was checked against first-party documentation on August 19, 2026.</p><ul><li><strong>LabEx</strong></li><li><strong>Backing environment:</strong> <strong>Ubuntu VM plus Linux and tool sandboxes</strong></li><li><strong>State:</strong> Retained within the active lab workflow</li><li><strong>Elevated access:</strong> Main Ubuntu VM: sudo for labex</li><li><strong>Learning support:</strong> <strong>Guided labs, checks, challenges, and contextual help</strong></li><li><strong>Best fit:</strong> Learning Linux in a complete system</li><li><strong>CoCalc</strong></li><li><strong>Backing environment:</strong> Hosted Linux project</li><li><strong>State:</strong> Persistent project files and snapshots</li><li><strong>Elevated access:</strong> No root</li><li><strong>Learning support:</strong> Course-oriented collaboration and shared terminals</li><li><strong>Best fit:</strong> Collaborative classes and computational work</li><li><strong>Coddy</strong></li><li><strong>Backing environment:</strong> Fresh Linux container per Run</li><li><strong>State:</strong> Stateless between submissions</li><li><strong>Elevated access:</strong> Not intended for system administration</li><li><strong>Learning support:</strong> Command examples and related guides</li><li><strong>Best fit:</strong> Testing one Bash block without an account</li><li><strong>WebTerm</strong></li><li><strong>Backing environment:</strong> Browser command simulator</li><li><strong>State:</strong> Reset on page reload</li><li><strong>Elevated access:</strong> Simulated commands only</li><li><strong>Learning support:</strong> Interactive command and Git tutorials</li><li><strong>Best fit:</strong> Learning basic syntax without an account</li><li><strong>Google Cloud Shell</strong></li><li><strong>Backing environment:</strong> Debian-based VM with containerised workspace</li><li><strong>State:</strong> 5 GB persistent $HOME; session VM is temporary</li><li><strong>Elevated access:</strong> Full root privileges and sudo</li><li><strong>Learning support:</strong> Product documentation</li><li><strong>Best fit:</strong> Google Cloud operations</li><li><strong>AWS CloudShell</strong></li><li><strong>Backing environment:</strong> Amazon Linux 2023 compute environment</li><li><strong>State:</strong> 1 GB persistent $HOME per Region in public environments</li><li><strong>Elevated access:</strong> Root inside the container and sudo</li><li><strong>Learning support:</strong> AWS tutorials</li><li><strong>Best fit:</strong> AWS operations</li><li><strong>Azure Cloud Shell</strong></li><li><strong>Backing environment:</strong> Microsoft-managed Linux container</li><li><strong>State:</strong> Optional Azure Files mount; otherwise ephemeral</li><li><strong>Elevated access:</strong> No sudo</li><li><strong>Learning support:</strong> Azure training material</li><li><strong>Best fit:</strong> Azure CLI or PowerShell operations</li><li><strong>GitHub Codespaces</strong></li><li><strong>Backing environment:</strong> Dev container on a dedicated Linux VM</li><li><strong>State:</strong> Project workspace persists with the codespace</li><li><strong>Elevated access:</strong> Root inside the dev container</li><li><strong>Learning support:</strong> Repository documentation and configuration</li><li><strong>Best fit:</strong> Cloud software development</li></ul><h4>Why LabEx ranks first for learning Linux</h4><p>The <a href="https://labex.io/tutorials/linux-online-linux-terminal-and-playground-372915">LabEx Online Linux Terminal</a> opens into an Ubuntu virtual machine rather than a fixed command simulator. The current <a href="https://support.labex.io/en/using-labex/virtual-machine">VM documentation</a> specifies Ubuntu 22.04, a labex user with sudo privileges, and three interfaces connected to the same environment:</p><ul><li><strong>Terminal</strong> for direct command-line work;</li><li><strong>WebIDE</strong> for editing files in a VS Code-like interface;</li><li><strong>Desktop</strong> for graphical applications and visual file operations.</li></ul><figure><img alt="The LabEx Linux environment with Desktop, WebIDE, Terminal, and Web 8080 tabs" src="https://cdn-images-1.medium.com/max/1024/0*V7DhE0JtjG0J90i7.png" /></figure><p><em>Terminal, WebIDE, Desktop, and web preview expose different views of the same Linux environment. Screenshot from the </em><a href="https://labex.io/tutorials/linux-online-linux-terminal-and-playground-372915"><em>Online Linux Terminal</em></a><em>.</em></p><p>The shared VM matters more than the number of tabs. Create a file in the terminal and the WebIDE can edit that same file. Start a web service and the preview can open it. Change permissions and the next command sees the changed modes. The learner is operating one system whose state continues across actions.</p><p>LabEx also gives that system a learning loop. <a href="https://labex.io/labs/linux-your-first-linux-lab-270253?course=quick-start-with-linux">Your First Linux Lab</a> introduces the environment through commands and step checks. In Guided Labs, verification tests whether the VM reached the required state. The <a href="https://support.labex.io/en/using-labex/labby-ai">Labby documentation</a> describes debugging and concept clarification inside the active lab workflow.</p><figure><img alt="LabEx switching from the Linux desktop to another environment interface" src="https://cdn-images-1.medium.com/max/800/0*-zmvwI1fe58JFl-u.gif" /></figure><p><em>The interface can change while the current lab environment remains in place.</em></p><p>That produces a concrete progression:</p><ol><li>Read the task beside a prepared Linux system.</li><li>Run commands and inspect their effects.</li><li>Check whether the required state exists.</li><li>Diagnose a failed check and retry.</li><li>Move to a Challenge that states the objective with less procedural guidance.</li></ol><p>The <a href="https://labex.io/learn/linux">Linux learning path</a> continues from command-line basics into shell scripting, system administration, security, projects, and challenges. A blank cloud shell can run many of the same commands; it does not supply this sequence or check what the learner changed.</p><h4>Beyond one Ubuntu VM: LabEx Playgrounds</h4><p>The main Online Linux Terminal uses Ubuntu, but LabEx is not limited to one distribution or one terminal configuration. The <a href="https://labex.io/playgrounds">LabEx Playgrounds catalog</a> currently lists 52 browser-based sandbox environments.</p><p>The Linux section includes Ubuntu, Ubuntu Desktop, Debian, Alpine, CentOS, RHEL, Fedora, Arch Linux, and openSUSE. Other categories provide prepared environments for tools and workloads such as Kali Linux, Docker, Kubernetes, Ansible, databases, programming languages, and AI coding agents. This lets a learner move from a general Linux terminal into an environment chosen for the next task without configuring it locally.</p><figure><img alt="The LabEx Playgrounds catalog showing Ubuntu, Debian, Alpine, CentOS, RHEL, Fedora, Arch Linux, and openSUSE sandboxes" src="https://cdn-images-1.medium.com/max/1024/0*zyXtHsx7mfUHGxrn.jpg" /></figure><p><em>The Linux section of </em><a href="https://labex.io/playgrounds"><em>LabEx Playgrounds</em></a><em> provides several distributions rather than a single Ubuntu entry point.</em></p><p>The useful distinction is between the environment and the lesson layered around it. A Playground supplies a prepared sandbox for open exploration. A Guided Lab adds instructions and checks. A Challenge states the objective with less procedural help. The learner can therefore choose both the Linux environment and the amount of guidance required.</p><h4>Use the online Linux terminal in the iOS and macOS apps</h4><p>The browser is not the only client. LabEx also provides native apps for iPhone and Mac. The <a href="https://support.labex.io/en/labex-app/virtual-machine-and-terminal">LabEx App VM documentation</a> says the app attaches a remote VM to the current lab, while instructions, Labby, and checks remain in the learning interface.</p><p>On iPhone, the VM opens in a sheet that can move between medium and large heights. The sheet shows setup progress and remaining session time, then provides terminal actions, interface switching, VM controls, and exposed ports. This makes it possible to start or resume terminal-based lab work from iOS without turning the phone into the machine running Linux.</p><figure><img alt="The LabEx iPhone app showing a lab step while its remote VM prepares the terminal session" src="https://cdn-images-1.medium.com/max/460/0*XAalKjMrN-NtlBth.png" /></figure><p><em>The iPhone app keeps the lab instructions visible while the remote Linux environment starts.</em></p><p>On macOS, the terminal is embedded in a wider learning workspace. Terminals and exposed ports appear in the sidebar, while the current instructions, assistant, and verification result can remain visible beside the shell. The same split that matters in the browser remains intact: Linux runs in the remote environment; the app provides a native interface to operate it.</p><figure><img alt="The LabEx macOS app with an embedded Linux terminal, lab instructions, assistant, and verification panel" src="https://cdn-images-1.medium.com/max/1024/0*HBQBtLGLSnnSQrIJ.png" /></figure><p><em>The macOS app places the real terminal beside the current lab context and verification controls.</em></p><p>LabEx adds more structure than a one-box runner, so it is not the quickest choice for checking whether one pipeline parses. It fits when the next question is “Did I change the Linux system correctly?” rather than only “Did this command produce output?”</p><h4>How the other real Linux environments differ</h4><h4>CoCalc: persistent Linux projects and collaboration</h4><p><a href="https://cocalc.io/features/terminal">CoCalc’s online Linux terminal</a> runs remotely and keeps project files with snapshots. Its distinguishing feature is real-time collaboration: several users can open a synchronized terminal and work beside a chat panel. That is useful for teaching a class or sharing computational work.</p><p>CoCalc documents two boundaries that matter here. Users do not receive root access, and outbound internet access in a free project requires a license. It provides a real, persistent Linux project, but it is organised around collaboration and a broad scientific software stack rather than a checked Linux learning path.</p><h4>Google and AWS Cloud Shell: real Linux for cloud operations</h4><p><a href="https://cloud.google.com/shell/docs/how-cloud-shell-works">Google Cloud Shell</a> provisions a temporary Compute Engine VM running Debian-based Linux. The default workspace is a container on that VM. Users have sudo, while a 5 GB persistent $HOME survives after the session VM is discarded.</p><p><a href="https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html">AWS CloudShell</a> provides an Amazon Linux 2023 compute environment with AWS credentials from the current console session. AWS documents 1 vCPU, 2 GiB of RAM, sudo, root access inside the container, and 1 GB of persistent home storage per Region for public environments.</p><p>Both are capable Linux shells. Their pre-authenticated cloud context is an advantage when the task is gcloud or AWS CLI work. For a Linux beginner, that same context introduces projects, IAM, Regions, quotas, and cloud-resource permissions that are unrelated to learning chmod, package management, or service diagnosis.</p><h4>GitHub Codespaces: a terminal inside a development workspace</h4><p><a href="https://docs.github.com/en/codespaces/about-codespaces/deep-dive">GitHub Codespaces</a> assigns a dedicated Linux VM, clones a repository into /workspaces, and creates a Docker development container. It combines the terminal with browser-based VS Code, port forwarding, repository settings, and repeatable devcontainer.json configuration. Root access is available inside the dev container.</p><p>That makes Codespaces the better choice when the repository and editor are part of the task. It is a larger conceptual starting point for command-line practice: the user may encounter repository ownership, machine sizes, containers, ports, commits, and usage accounting before those concepts belong in the lesson.</p><h4>Azure Cloud Shell: convenient, but deliberately restricted</h4><p><a href="https://learn.microsoft.com/en-us/azure/cloud-shell/faq-troubleshooting">Azure Cloud Shell</a> offers Bash or PowerShell with Azure tools already configured. Sessions time out after 20 minutes of inactivity. Persistent files require an Azure Files mount; without one, the session is ephemeral.</p><p>Microsoft documents the user as unprivileged: sudo and other elevated commands are unavailable. That boundary is reasonable for a managed Azure console, but it prevents system-administration exercises that install protected packages, create users, modify system configuration, or manage services as root.</p><h4>Where instant runners and simulators fit</h4><p><a href="https://coddy.tech/playground/terminal">Coddy</a> executes real Bash and GNU tools in a server-side Linux container without requiring an account. Every Run starts in a fresh /home, so a pipeline or multi-line script works, but a standalone cd, created file, or environment variable cannot affect the next submission. It is useful when the whole task fits in one command block.</p><p><a href="https://webterm.app/en/free-play">WebTerm Free Play</a> takes the browser-only approach. Its virtual file tree, pipes, redirection, Git workflows, and implemented commands support basic practice without registration. WebTerm also states that it is a simulator rather than a virtual machine. Reloading resets the environment, and there is no Linux backend on which to install an arbitrary package or inspect a real service.</p><p>These tools are not defective versions of a VM. They solve smaller problems with less startup and account friction. The mistake is treating their terminal-shaped interfaces as evidence that they can reproduce system administration on Linux.</p><h4>Choose by the task behind the terminal</h4><ul><li>Use <strong>LabEx</strong> to learn Linux through real remote environments, checked tasks, and progressively reduced guidance, with additional Playgrounds and native iPhone and Mac access when the workflow needs them.</li><li>Use <strong>CoCalc</strong> when several people need a persistent shared terminal or a broad computational software stack.</li><li>Use <strong>Coddy</strong> to test one self-contained Bash block without creating an account.</li><li>Use <strong>WebTerm</strong> for browser-only command syntax and Git tutorials, with the simulator boundary in mind.</li><li>Use <strong>Google Cloud Shell</strong>, <strong>AWS CloudShell</strong>, or <strong>Azure Cloud Shell</strong> to operate resources in the matching cloud account.</li><li>Use <strong>GitHub Codespaces</strong> when a repository, editor, dev container, and terminal should form one development workspace.</li></ul><p>For a first session on an actual Linux system, open <a href="https://labex.io/labs/linux-your-first-linux-lab-270253?course=quick-start-with-linux">Your First Linux Lab</a>. Run whoami, uname -a, ps aux, and cat /etc/os-release; then make a change and use the lab check to verify the resulting state.</p><h4>References</h4><ul><li><a href="https://labex.io/tutorials/linux-online-linux-terminal-and-playground-372915">LabEx Online Linux Terminal</a>, <a href="https://support.labex.io/en/using-labex/virtual-machine">Virtual Machine documentation</a>, and <a href="https://support.labex.io/en/using-labex/labby-ai">Labby documentation</a> — environment model, interfaces, privileges, checks, and contextual help.</li><li><a href="https://labex.io/playgrounds">LabEx Playgrounds</a> — current Linux distributions and the broader catalog of sandbox environments.</li><li><a href="https://support.labex.io/en/labex-app/overview-and-get-started">LabEx App overview</a> and <a href="https://support.labex.io/en/labex-app/virtual-machine-and-terminal">VM and terminal documentation</a> — supported Apple platforms, remote VM controls, terminals, forwarded ports, and learning layout.</li><li><a href="https://cocalc.io/features/terminal">CoCalc Online Linux Terminal</a> — remote Linux environment, collaboration, persistence, root, and network boundaries.</li><li><a href="https://coddy.tech/playground/terminal">Coddy Online Linux Terminal</a> — server-side Linux execution and stateless runs.</li><li><a href="https://webterm.app/en/free-play">WebTerm Free Play</a> — simulator model, implemented workflows, and reset behaviour.</li><li><a href="https://cloud.google.com/shell/docs/how-cloud-shell-works">Google Cloud Shell architecture</a> — VM, container, privileges, lifecycle, and persistent storage.</li><li><a href="https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html">AWS CloudShell overview</a>, <a href="https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html">environment specification</a>, and <a href="https://docs.aws.amazon.com/cloudshell/latest/userguide/cloudshell-security-faqs.html">security FAQ</a> — Linux image, resources, storage, and root boundary.</li><li><a href="https://learn.microsoft.com/en-us/azure/cloud-shell/features">Azure Cloud Shell features</a> and <a href="https://learn.microsoft.com/en-us/azure/cloud-shell/faq-troubleshooting">FAQ</a> — persistence choices, timeout, and privilege restrictions.</li><li><a href="https://docs.github.com/en/codespaces/about-codespaces/deep-dive">GitHub Codespaces technical overview</a> — VM and dev-container model, repository lifecycle, interfaces, and privileges.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4838b4258bc7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[KodeKloud vs LabEx: Which Hands-On Learning Model Fits You?]]></title>
            <link>https://labexio.medium.com/kodekloud-vs-labex-which-hands-on-learning-model-fits-you-9474cd82310e?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/9474cd82310e</guid>
            <category><![CDATA[labex]]></category>
            <category><![CDATA[articles]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Thu, 13 Aug 2026 00:20:22 GMT</pubDate>
            <atom:updated>2026-08-13T00:29:38.594Z</atom:updated>
            <content:encoded><![CDATA[<p>Open a beginner Linux course on KodeKloud and you may meet an instructor, a fictional workplace, a quiz, and then a terminal lab.</p><p>Open the comparable course on LabEx and the lesson begins beside the environment where you will run the commands.</p><p>Both platforms lead to hands-on work. They differ in what they put before it, what happens when a check fails, how they remove guidance, and how completed practice becomes evidence of a skill.</p><p>That makes “Does it have labs?” a poor way to compare KodeKloud and LabEx. Both do. A more useful question is which learning loop helps you move from following an explanation to solving a system problem without one.</p><blockquote><strong>The useful comparison is not whether either platform has labs. It is what the platform can understand about your work when the expected result does not appear.</strong></blockquote><h4>The Short Version</h4><p>• Learn from instructor-led videos before practicing<br> Start with: KodeKloud<br> Why: Its courses commonly combine narrated lessons, quizzes, stories, and browser labs.</p><p>• Prepare for CKA, CKAD, CKS, or another named certification<br> Start with: Either, with different formats<br> Why: KodeKloud emphasizes video-led courses and mock exams; LabEx organizes hands-on prep and practice exams inside certification Skill Trees.</p><p>• Learn mainly by reading and operating the environment<br> Start with: LabEx<br> Why: Its default format is no-video, with instructions, a VM, and verification in the same workflow.</p><p>• Get feedback based on the current lab and your recent actions<br> Start with: LabEx<br> Why: Labby works with the active lab context, while Deep Inspection can review operation logs after a failed verification.</p><p>• Move from guided practice to minimally guided problems<br> Start with: Either, with different structures<br> Why: KodeKloud offers Engineer tasks and challenge programs; LabEx places Guided Labs and Challenge Labs inside its course and Skill Tree model.</p><p>• Track progress as evidence against individual technical skills<br> Start with: LabEx<br> Why: Labs, challenges, projects, and assessments can contribute evidence to concept-level skills rather than only course completion.</p><p>• Keep labs, AI help, solutions, and projects in one lower-cost plan<br> Start with: LabEx<br> Why: LabEx Pro lists these together at $99.90 per year; KodeKloud distributes advanced practice and AI across higher subscription tiers.</p><p>This is not a ranking. A learner preparing for a certification may prefer KodeKloud’s instructor-led sequence or LabEx’s no-video, lab-first route. Someone who routinely skips course videos may reach the terminal faster with LabEx even when both catalogs cover the same command.</p><h4>Before the Terminal: Two Ways to Introduce a Topic</h4><h4>KodeKloud: Explain, Then Practise</h4><p>KodeKloud’s <a href="https://kodekloud.com/courses/the-linux-basics-course">Linux Basics course</a> shows its teaching pattern clearly. It mixes videos, a continuing story about a fictional company, multiple-choice questions, articles, and labs.</p><p>A section on the shell includes video lessons before the corresponding terminal exercises. Later sections repeat the pattern for package management, the Linux kernel, networking, storage, and service management.</p><p>The browser lab is not an optional appendix. KodeKloud says each lecture is followed by a hands-on lab where it validates the learner’s work and provides feedback or hints.</p><p><strong>Typical rhythm:</strong> watch → answer → practise → receive feedback.</p><figure><img alt="KodeKloud Linux course modules alongside course features such as video, story format, and labs" src="https://cdn-images-1.medium.com/max/1024/0*Vld83qBixxEstaJT.jpg" /></figure><p><em>KodeKloud’s public Linux course page presents modules beside video length, story format, and lab access.</em></p><h4>LabEx: Explain Inside the Practice</h4><p>LabEx starts from a different constraint. Its <a href="https://support.labex.io/en/using-labex/welcome">support documentation</a> describes the platform as no-video and organizes instruction around browser environments with automated checks. In <a href="https://labex.io/courses/quick-start-with-linux">Quick Start with Linux</a>, the course sequence contains five Guided Labs and five Challenges. The learner reads the explanation while working in the environment rather than watching a lecture before opening it.</p><p><strong>Typical rhythm:</strong> read → operate → check → retry.</p><figure><img alt="The LabEx Quick Start with Linux syllabus mixing guided labs and challenge activities" src="https://cdn-images-1.medium.com/max/930/0*n4SjkoYZHFoKRwud.jpg" /></figure><p><em>LabEx’s course syllabus places guided labs and challenge activities in one sequence; the two activity types use different icons.</em></p><figure><img alt="A video lesson and a written guide both leading into terminal practice" src="https://cdn-images-1.medium.com/max/1024/0*8yremolEaB5QBC26.png" /></figure><p><em>Different routes, same destination: the meaningful work still happens in a running environment.</em></p><p>Neither sequence is inherently more rigorous:</p><ul><li><strong>Video before the lab</strong> can make architecture, process, and visual relationships easier to introduce.</li><li><strong>Text beside the terminal</strong> makes it easier to pause on a command, inspect the current state, and retry without moving between a player and a lab.</li></ul><p>The useful distinction is the amount and form of explanation you want before touching the system.</p><h4>A Passing Check Is Only the Beginning</h4><p>Both platforms remove much of the setup work that can consume a beginner’s study session. In either one, a learner can:</p><ul><li>open a prepared environment in the browser;</li><li>run commands and change configuration;</li><li>submit the resulting state to automated checks;</li><li>retry without first rebuilding a disposable Linux or Kubernetes machine locally.</li></ul><p>Both also check work rather than treating terminal activity as proof by itself. KodeKloud’s Linux course describes labs that validate answers and return feedback. In LabEx, a Guided Lab runs a verification script against the VM after a step.</p><blockquote>Running chmod does not establish that the resulting permissions are correct. A useful lab checks the state that the command produced.</blockquote><p>This shared mechanism matters more than catalog slogans. The learner has to connect a command, its effect, and the requirement the checker is enforcing. But a deterministic script usually answers only one question: does the current state satisfy the rule it was written to test?</p><h4>LabEx Adds Context to a Failed Check</h4><p><a href="https://support.labex.io/en/using-labex/labby-ai">Labby</a> is connected to the active lab workflow rather than operating as a detached chatbot. LabEx’s documentation says that step verification runs inside the VM. The current <a href="https://labex.io/tutorials/linux-your-first-linux-lab-270253">Your First Linux Lab</a> goes further: its Ask feature understands the current lab context and recent actions, so a learner can ask where a mistake occurred, request a learning report based on the session, or ask how to improve.</p><p>The same lab contains a deliberately failed verification after the learner runs id -un. Clicking <strong>Re-Inspect</strong> triggers <strong>Deep Inspection</strong>, which uses AI to review the operation logs. It can then give feedback tied to what the learner actually did instead of repeating a generic hint for everyone who failed the same step.</p><ul><li><strong>Verification script — state inside the VM:</strong> produces a deterministic pass or failure.</li><li><strong>Deep Inspection — failed check and operation logs:</strong> provides a contextual diagnosis and a more relevant next action.</li><li><strong>Ask Labby — question, current lab, and recent actions:</strong> provides targeted explanation, debugging help, or session feedback.</li></ul><figure><img alt="Labby answering a technical question inside the LabEx learning interface" src="https://cdn-images-1.medium.com/max/807/0*5d3vboQNos8tECaa.png" /></figure><p><em>Labby remains inside the learning workflow, with actions for asking questions, debugging, explaining code, and returning to the running lab. Image from the </em><a href="https://support.labex.io/en/using-labex/labby-ai"><em>LabEx AI Assistant documentation</em></a><em>.</em></p><p>This does not make every diagnosis infallible. A verification script can be too narrow, and an AI inspection can misread an unusual sequence of actions. The advantage is the additional evidence available when a plain pass/fail result is not enough.</p><p>The distinction appears again in how the environment is presented. KodeKloud offers course labs as well as open DevOps and cloud Playgrounds for experiments without predefined instructions. A <a href="https://support.labex.io/en/using-labex/virtual-machine">LabEx VM</a> can expose a Linux desktop, WebIDE, or terminal depending on the task. These are different interfaces around the same important idea: the learner should change a running environment, not only recall an answer.</p><h4>What Happens When the Instructions Stop?</h4><p>A guided lab can confirm that you followed a procedure. It cannot, by itself, show whether you would recognize when to use that procedure.</p><h4>KodeKloud Engineer: The Task as a Work Ticket</h4><p>KodeKloud addresses that gap most visibly through <a href="https://support.kodekloud.com/what-is-kodekloud-engineer">KodeKloud Engineer</a>. The program places the learner in a fictional organization, provides project documentation and systems, and assigns operational tasks.</p><p>The surrounding fiction gives each task the shape of a work ticket rather than another chapter in a course. KodeKloud’s <a href="https://kodekloud.com/blog/kodekloud-engineer-2-0/">Engineer 2.0 overview</a> lists tasks in Linux, Git, Docker, Kubernetes, Jenkins, and Ansible.</p><h4>LabEx Challenge: The Task as a Skill Check</h4><p>LabEx uses <a href="https://support.labex.io/en/using-labex/quick-start">Challenge Labs</a> for the same transition from instruction to application. A Challenge usually keeps the objectives and requirements but removes most explanatory steps. The learner must inspect the supplied state, decide which commands or files matter, make the change, and satisfy the checks.</p><p>• Context<br> KodeKloud Engineer: Fictional organization and operational task<br> LabEx Challenge: A stated objective in a prepared technical environment</p><p>• Connection to learning<br> KodeKloud Engineer: A distinct job-simulation experience<br> LabEx Challenge: Linked to courses and concept-level Skill Trees</p><p>• Likely appeal<br> KodeKloud Engineer: Learners who value workplace narrative<br> LabEx Challenge: Learners who want a direct concept-to-check loop</p><figure><img alt="Guidance leading to terminal work and then to verified evidence" src="https://cdn-images-1.medium.com/max/1024/0*vE--AgTfzRfrRERi.png" /></figure><p><em>The transition that matters: follow less, decide more, then verify the resulting state.</em></p><p>Neither should be described as employment or production experience. The systems are controlled learning environments. Their value is that they can expose a gap hidden by step-by-step completion: knowing a command is different from diagnosing when and how to use it.</p><h4>Certification Preparation Is No Longer a One-Sided Comparison</h4><p>Certification preparation is a traditional KodeKloud strength. Its <a href="https://kodekloud.com/learning-path/cka">CKA Learning Path</a>, for example, moves through Linux, containers, Kubernetes, a dedicated CKA course, and mock exams. The same catalog has named paths for <a href="https://kodekloud.com/learning-path/ckad">CKAD</a> and <a href="https://kodekloud.com/learning-path/cks">CKS</a>. This is a clear fit for learners who want an instructor-led course sequence ending in exam-shaped practice.</p><p>LabEx now covers much of the same certification decision. Its public <a href="https://labex.io/skilltrees">Skill Trees catalog</a> lists CKA, CKAD, and CKS training alongside RHCSA, RHCE, LFCS, and CompTIA Linux+, A+, Network+, and Security+ preparation. For each of CKA, CKAD, and CKS, the catalog groups three courses: a preparation course and two practice-exam courses.</p><p>The distinction is therefore less about whether certification content exists and more about how it is delivered:</p><p>• How is the syllabus introduced?<br> KodeKloud: Instructor-led video courses followed by labs<br> LabEx: No-video explanations beside live environments</p><p>• How does exam practice appear?<br> KodeKloud: Dedicated certification courses, readiness tests, and mock exams<br> LabEx: Hands-on prep courses and practice exams inside certification Skill Trees</p><p>• What does progress connect to?<br> KodeKloud: A course and certification learning path<br> LabEx: A certification path plus reusable Kubernetes, Linux, and security skills</p><p>Neither platform awards the CKA, CKAD, or CKS credential itself. Those credentials still come from the certification body after the learner passes its exam. The platforms provide preparation, labs, and practice exams; their course-completion certificates are a separate record.</p><h4>Course Progress and Skill Evidence Are Not the Same Thing</h4><p>KodeKloud’s <a href="https://kodekloud.com/learning-paths/">Learning Paths</a> answer a planning question: which courses should someone take for a domain, certification, or role? The current catalog includes domain paths for Linux, Kubernetes, cloud platforms, infrastructure as code, and AI, as well as role paths for system administrators, DevOps engineers, platform engineers, and other infrastructure roles. Course certificates, readiness tests, and KodeKloud Engineer progression provide several ways to represent work completed inside those paths.</p><p>LabEx also has courses and certificates, but its <a href="https://support.labex.io/en/using-labex/skill-trees">Skill Trees</a> add a separate layer. A Skill Tree is a map of the capabilities inside a technical domain, not merely another order in which to consume lessons.</p><p>The relationship is many-to-many: one lab can teach or assess several skills, while one skill can receive evidence from several Guided Labs, Challenge Labs, projects, or assessments. This matters for learners who do not follow one linear course from the beginning. Existing ability in file operations can remain distinct from gaps in Linux services, networking, or process management.</p><figure><img alt="A LabEx Skill Tree connecting a technical domain to skill groups, individual skills, and related labs" src="https://cdn-images-1.medium.com/max/702/0*hmyp7P3TXZ7czfs2.png" /></figure><p><em>The Skill Tree structure connects a domain to reusable skills and then to the labs that practise them. Image from the </em><a href="https://support.labex.io/en/using-labex/skill-trees"><em>LabEx Skill Trees documentation</em></a><em>.</em></p><p>The <a href="https://github.com/labex-labs/labex-skilltrees">public Skill Trees V2 catalog</a> makes the structure inspectable outside the product UI. It defines domain boundaries, stable skill identifiers, names, descriptions, and canonical ordering. Each skill is intended to represent a reusable concept-level capability rather than one command option or one step in one lab.</p><p>That distinction changes what a progress page can answer:</p><ul><li><strong>Course completion:</strong> Did the learner reach the end of this sequence?</li><li><strong>Skill evidence:</strong> Which concepts did the completed work exercise across courses, challenges, projects, or assessments?</li></ul><p>The second view can reveal that finishing one course did not exercise every skill in the tree. It can also combine evidence from different courses when they exercise the same underlying capability.</p><p>The careful word here is <em>evidence</em>, not proof of job readiness. A completed LabEx challenge records performance inside that challenge’s environment and checks. It does not establish how someone will perform in every unfamiliar system. The Skill Tree makes the platform’s interpretation visible; it does not remove the limits of platform-based assessment.</p><h4>Price Changes the Practical Comparison</h4><p>Price is volatile, but omitting it would hide one of LabEx’s clearest advantages. As of August 12, 2026, <a href="https://labex.io/pricing">LabEx Pro</a> is listed at <strong>$99.90 per year</strong>. That plan includes 6,000+ hands-on labs, unlimited virtual machines, 2,000+ challenge solutions, 400+ projects, completion certificates, and full access to Labby.</p><p><a href="https://kodekloud.com/pricing/">KodeKloud’s pricing</a> is regional and promotion-dependent, so its checkout price should be checked directly. Its feature split is still useful to compare: Standard includes the main course library and 1,280 hands-on labs; Pro adds playgrounds, cloud labs, projects, and unlimited KodeKloud Engineer work; the AI tier adds the personalized tutor and AI-assisted labs.</p><p>• Free hands-on access<br> LabEx: 3 VMs per day<br> KodeKloud: Limited free courses and features</p><p>• Unlimited core labs<br> LabEx: Included in Pro<br> KodeKloud: Included in Standard and above</p><p>• AI assistance in the learning workflow<br> LabEx: Full Labby access in Pro<br> KodeKloud: Personalized tutor and AI-assisted labs in the AI tier</p><p>• Challenges, solutions, and projects<br> LabEx: Included in Pro<br> KodeKloud: Access and task limits vary across Standard, Pro, and AI</p><p>The value advantage is not just a lower headline price. A learner who wants labs, project and challenge practice, solutions, and contextual AI help can obtain that bundle in one LabEx Pro subscription. The products are not feature-for-feature identical — KodeKloud also funds a large instructor-led video catalog — so the fair conclusion is narrower: <strong>for learners primarily buying hands-on practice and AI-assisted feedback, LabEx offers the stronger all-in price.</strong></p><h4>Which Platform Fits Your Learning Loop?</h4><h4>Start With KodeKloud If…</h4><ul><li>You want an instructor-led DevOps or cloud curriculum.</li><li>You want instructor-led certification preparation with a long-established video and mock-exam sequence.</li><li>A role-based sequence helps you decide what to learn next.</li><li>Workplace narrative makes independent tasks more engaging.</li></ul><p>Its videos and labs are designed to support each other, and KodeKloud Engineer provides a distinct place to practise ticket-shaped tasks after learning the foundations.</p><h4>Start With LabEx If…</h4><ul><li>Video is the part of online learning you usually skip.</li><li>You prefer reading instructions beside a live environment.</li><li>You want AI help that can use the current lab, recent actions, and failed verification context.</li><li>You want a direct progression from Guided Labs to Challenges.</li><li>You want progress represented as concept-level skill evidence across courses.</li><li>You want hands-on certification paths and AI-assisted practice in one lower-cost annual plan.</li></ul><p>The default interaction is reading, operating a VM, checking the result, and moving from guidance to a less-prescriptive problem.</p><p>Topic coverage can change the answer. KodeKloud’s public catalog is strongly developed around DevOps, Kubernetes, cloud, platform engineering, certification preparation, and newer AI topics. LabEx exposes learning directions beyond infrastructure, including programming languages, databases, data science, web development, and cybersecurity. A larger category list does not establish depth, so compare the actual course and challenge sequence for the subject you intend to study.</p><blockquote><strong>Compare the actual course and challenge sequence, then compare the plan that unlocks the features you will use.</strong> A low entry price is less informative than the total cost of labs, AI help, solutions, and independent practice.</blockquote><h4>A 30-Minute Test Before You Choose</h4><p>Use the same small Linux topic on both platforms. File permissions, process inspection, or package management works better than comparing two unrelated flagship courses.</p><ol><li><strong>Measure time to terminal.</strong> Start a free beginner lab and note how long it takes before you run the first meaningful command.</li><li><strong>Make a reversible mistake.</strong> Check whether the feedback merely states the expected answer or can explain the failure using what you actually did. In LabEx, compare the initial check with Re-Inspect and an Ask Labby question.</li><li><strong>Remove the procedure.</strong> Complete one guided task, then find a Challenge or Engineer task covering related skills.</li><li><strong>Inspect the evidence.</strong> Can you tell what capability was exercised and what remains, or only that the activity is finished?</li><li><strong>Choose for your real habits.</strong> Prefer the balance of explanation, terminal time, feedback, and independent work that matches how you actually study.</li></ol><p>The better platform is the one that gets you from a correct walkthrough to an unfamiliar system state with enough support to recover, but not so much that the decisions have already been made for you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9474cd82310e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Display User and Group Information Challenge Solution]]></title>
            <link>https://labexio.medium.com/display-user-and-group-information-challenge-solution-62ebf2471af0?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/62ebf2471af0</guid>
            <category><![CDATA[labex]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[sysadmin]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 01:07:37 GMT</pubDate>
            <atom:updated>2026-07-09T01:07:37.603Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Display User and Group Information Challenge Solution" src="https://cdn-images-1.medium.com/max/1024/0*XFJJo5RbW3ITRhm_.png" /></figure><p>The LabEx challenge <a href="https://labex.io/labs/linux-display-user-and-group-information-8718">Display User and Group Information</a> is short, but it tests an important Linux reflex: before reasoning about permissions, confirm which user the shell is running as and which groups that user belongs to.</p><p>Unlike a guided lab, this is a challenge. The page gives the required outcome, but it expects you to choose the commands yourself. The solution comes from matching each requirement to the Linux command that reports exactly that information.</p><h4>Problem Summary</h4><p>The challenge has two tasks:</p><ul><li>Display the current user identity.</li><li>Display detailed user and group information, including uid, gid, and groups.</li></ul><p>That means the answer needs two levels of identity information. The first task only wants the username. The second task wants the numeric and named identity fields Linux uses for access decisions.</p><h4>Step 1: Print the Current Username</h4><p>For the first task, use whoami.</p><pre>whoami</pre><p>The expected output is only the current username. In the LabEx environment, it may look like this:</p><pre>labex</pre><p>This command answers a narrow question: “Which user am I right now?” It does not show groups, IDs, or permission details. That is why it is the right command for the first requirement, but not enough for the second one.</p><h4>Step 2: Print User and Group Details</h4><p>For the second task, use id.</p><pre>id</pre><p>The output should include the user ID, primary group ID, and supplementary groups:</p><pre>uid=1000(labex) gid=1000(labex) groups=1000(labex),4(adm),24(cdrom),27(sudo)</pre><figure><img alt="Terminal showing the whoami and id commands for the challenge solution" src="https://cdn-images-1.medium.com/max/1024/0*KtFhuxIG1m_DU1kQ.png" /></figure><p>The exact numbers and group names can differ between environments. What matters is the structure:</p><ul><li>uid=1000(labex) means the current user has numeric user ID 1000 and username labex.</li><li>gid=1000(labex) means the primary group ID is 1000 and the group name is labex.</li><li>groups=... lists every group membership available to the current user.</li></ul><h4>Why These Commands Solve the Challenge</h4><p>whoami solves the first requirement because it prints only the current username. If the challenge asks for a single user identity, this is the cleanest output.</p><p>id solves the second requirement because it includes the fields named in the prompt: uid, gid, and groups. You do not need to inspect /etc/passwd or /etc/group for this challenge. Those files can explain account configuration, but the task asks for the identity information of the current session, and id reports that directly.</p><p>The common mistake is to stop after whoami. That confirms the username, but it does not prove group membership. In Linux permission checks, group membership can be the difference between access granted and access denied.</p><h4>Final Answer</h4><p>Run these two commands:</p><pre>whoami<br>id</pre><p>You have completed the challenge when the first command prints the current username and the second command prints identity details containing uid, gid, and groups.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62ebf2471af0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learn Linux by Doing 100 Small Tasks]]></title>
            <link>https://labexio.medium.com/learn-linux-by-doing-100-small-tasks-10e44942a210?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/10e44942a210</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[challenge]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Wed, 08 Jul 2026 00:45:07 GMT</pubDate>
            <atom:updated>2026-07-08T00:45:07.676Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*quQvOIdewXUc6F4Nbyupiw.png" /></figure><p>Learning Linux often feels harder than it should.</p><p>You may read tutorials, memorize commands, and still feel unsure when you open a terminal and need to actually do something.</p><p>That is why we created <strong>100 Days of Linux</strong>: a hands-on challenge course built around 100 small Linux tasks.</p><p>Each challenge gives you a practical scenario to complete in a real Linux environment, such as finding files, working with permissions, processing text, managing processes, checking services, handling packages, and troubleshooting system issues.</p><p>No local setup is required. You can start directly in your browser.</p><h3>Why Challenges?</h3><p>Linux is not something you learn well by only reading.</p><p>Most commands are not difficult on their own. The harder part is knowing when to use them, how to combine them, and how to check whether your solution actually works.</p><p>Challenges help bridge that gap. They turn Linux learning into small, concrete tasks you can finish one by one.</p><h3>Who Is It For?</h3><p>This course is mainly designed for beginners who have learned some Linux basics but still need more practice.</p><p>It can also be useful if you are preparing for DevOps, backend development, system administration, or cybersecurity.</p><h3>100 Linux Challenges</h3><p>Here is the full list of challenges included in the course.</p><h3>Days 1–10</h3><ol><li><a href="https://labex.io/labs/linux-claim-the-drop-folder-664834?course=100-days-of-linux-challenges">Claim the Drop Folder</a></li><li><a href="https://labex.io/labs/linux-inventory-the-delivery-664875?course=100-days-of-linux-challenges">Inventory the Delivery</a></li><li><a href="https://labex.io/labs/linux-read-the-welcome-note-664888?course=100-days-of-linux-challenges">Read the Welcome Note</a></li><li><a href="https://labex.io/labs/linux-create-the-ready-file-664847?course=100-days-of-linux-challenges">Create the Ready File</a></li><li><a href="https://labex.io/labs/linux-prepare-the-review-folder-664884?course=100-days-of-linux-challenges">Prepare the Review Folder</a></li><li><a href="https://labex.io/labs/linux-preserve-the-template-664885?course=100-days-of-linux-challenges">Preserve the Template</a></li><li><a href="https://labex.io/labs/linux-correct-the-handoff-name-664845?course=100-days-of-linux-challenges">Correct the Handoff Name</a></li><li><a href="https://labex.io/labs/linux-remove-the-retired-draft-664891?course=100-days-of-linux-challenges">Remove the Retired Draft</a></li><li><a href="https://labex.io/labs/linux-check-the-first-clue-664831?course=100-days-of-linux-challenges">Check the First Clue</a></li><li><a href="https://labex.io/labs/linux-close-the-first-handoff-664840?course=100-days-of-linux-challenges">Close the First Handoff</a></li></ol><h3>Days 11–20</h3><ol><li><a href="https://labex.io/labs/linux-find-the-customer-tag-664855?course=100-days-of-linux-challenges">Find the Customer Tag</a></li><li><a href="https://labex.io/labs/linux-triage-the-note-folder-664911?course=100-days-of-linux-challenges">Triage the Note Folder</a></li><li><a href="https://labex.io/labs/linux-count-the-import-records-664846?course=100-days-of-linux-challenges">Count the Import Records</a></li><li><a href="https://labex.io/labs/linux-sort-the-review-queue-664906?course=100-days-of-linux-challenges">Sort the Review Queue</a></li><li><a href="https://labex.io/labs/linux-clean-the-duplicate-queue-664836?course=100-days-of-linux-challenges">Clean the Duplicate Queue</a></li><li><a href="https://labex.io/labs/linux-extract-the-access-list-664851?course=100-days-of-linux-challenges">Extract the Access List</a></li><li><a href="https://labex.io/labs/linux-filter-the-active-checks-664854?course=100-days-of-linux-challenges">Filter the Active Checks</a></li><li><a href="https://labex.io/labs/linux-spot-the-missing-host-664907?course=100-days-of-linux-challenges">Spot the Missing Host</a></li><li><a href="https://labex.io/labs/linux-locate-the-backup-file-664876?course=100-days-of-linux-challenges">Locate the Backup File</a></li><li><a href="https://labex.io/labs/linux-build-the-filtered-batch-664826?course=100-days-of-linux-challenges">Build the Filtered Batch</a></li></ol><h3>Days 21–30</h3><ol><li><a href="https://labex.io/labs/linux-write-the-status-line-664918?course=100-days-of-linux-challenges">Write the Status Line</a></li><li><a href="https://labex.io/labs/linux-append-the-audit-entry-664820?course=100-days-of-linux-challenges">Append the Audit Entry</a></li><li><a href="https://labex.io/labs/linux-build-the-client-config-664825?course=100-days-of-linux-challenges">Build the Client Config</a></li><li><a href="https://labex.io/labs/linux-change-the-release-channel-664829?course=100-days-of-linux-challenges">Change the Release Channel</a></li><li><a href="https://labex.io/labs/linux-fix-the-config-typo-664863?course=100-days-of-linux-challenges">Fix the Config Typo</a></li><li><a href="https://labex.io/labs/linux-filter-failed-logins-664853?course=100-days-of-linux-challenges">Filter Failed Logins</a></li><li><a href="https://labex.io/labs/linux-capture-the-health-output-664828?course=100-days-of-linux-challenges">Capture the Health Output</a></li><li><a href="https://labex.io/labs/linux-fill-the-repeated-path-664852?course=100-days-of-linux-challenges">Fill the Repeated Path</a></li><li><a href="https://labex.io/labs/linux-handle-the-spaced-filename-664869?course=100-days-of-linux-challenges">Handle the Spaced Filename</a></li><li><a href="https://labex.io/labs/linux-submit-the-change-bundle-664909?course=100-days-of-linux-challenges">Submit the Change Bundle</a></li></ol><h3>Days 31–40</h3><ol><li><a href="https://labex.io/labs/linux-find-the-unsafe-permission-664862?course=100-days-of-linux-challenges">Find the Unsafe Permission</a></li><li><a href="https://labex.io/labs/linux-lock-the-private-note-664878?course=100-days-of-linux-challenges">Lock the Private Note</a></li><li><a href="https://labex.io/labs/linux-open-the-team-readme-664881?course=100-days-of-linux-challenges">Open the Team README</a></li><li><a href="https://labex.io/labs/linux-restore-directory-access-664897?course=100-days-of-linux-challenges">Restore Directory Access</a></li><li><a href="https://labex.io/labs/linux-handoff-the-owned-file-664870?course=100-days-of-linux-challenges">Handoff the Owned File</a></li><li><a href="https://labex.io/labs/linux-assign-the-team-group-664822?course=100-days-of-linux-challenges">Assign the Team Group</a></li><li><a href="https://labex.io/labs/linux-identify-the-service-account-664871?course=100-days-of-linux-challenges">Identify the Service Account</a></li><li><a href="https://labex.io/labs/linux-restore-reviewer-group-access-664898?course=100-days-of-linux-challenges">Restore Reviewer Group Access</a></li><li><a href="https://labex.io/labs/linux-audit-open-write-access-664823?course=100-days-of-linux-challenges">Audit Open Write Access</a></li><li><a href="https://labex.io/labs/linux-close-the-access-review-664837?course=100-days-of-linux-challenges">Close the Access Review</a></li></ol><h3>Days 41–50</h3><ol><li><a href="https://labex.io/labs/linux-find-the-running-worker-664859?course=100-days-of-linux-challenges">Find the Running Worker</a></li><li><a href="https://labex.io/labs/linux-target-the-worker-pid-664910?course=100-days-of-linux-challenges">Target the Worker PID</a></li><li><a href="https://labex.io/labs/linux-release-the-stale-lock-664890?course=100-days-of-linux-challenges">Release the Stale Lock</a></li><li><a href="https://labex.io/labs/linux-inspect-the-worker-setting-664873?course=100-days-of-linux-challenges">Inspect the Worker Setting</a></li><li><a href="https://labex.io/labs/linux-gate-the-next-step-on-success-664867?course=100-days-of-linux-challenges">Gate the Next Step on Success</a></li><li><a href="https://labex.io/labs/linux-run-the-export-in-background-664903?course=100-days-of-linux-challenges">Run the Export in Background</a></li><li><a href="https://labex.io/labs/linux-collect-the-export-result-664843?course=100-days-of-linux-challenges">Collect the Export Result</a></li><li><a href="https://labex.io/labs/linux-guard-the-slow-check-664868?course=100-days-of-linux-challenges">Guard the Slow Check</a></li><li><a href="https://labex.io/labs/linux-prepare-the-maintenance-script-664883?course=100-days-of-linux-challenges">Prepare the Maintenance Script</a></li><li><a href="https://labex.io/labs/linux-close-the-worker-handoff-664842?course=100-days-of-linux-challenges">Close the Worker Handoff</a></li></ol><h3>Days 51–60</h3><ol><li><a href="https://labex.io/labs/linux-check-the-local-health-page-664832?course=100-days-of-linux-challenges">Check the Local Health Page</a></li><li><a href="https://labex.io/labs/linux-find-the-listening-port-664856?course=100-days-of-linux-challenges">Find the Listening Port</a></li><li><a href="https://labex.io/labs/linux-match-port-to-process-664879?course=100-days-of-linux-challenges">Match Port to Process</a></li><li><a href="https://labex.io/labs/linux-name-the-local-service-664880?course=100-days-of-linux-challenges">Name the Local Service</a></li><li><a href="https://labex.io/labs/linux-fix-the-stale-service-name-664865?course=100-days-of-linux-challenges">Fix the Stale Service Name</a></li><li><a href="https://labex.io/labs/linux-prove-the-port-is-reachable-664887?course=100-days-of-linux-challenges">Prove the Port Is Reachable</a></li><li><a href="https://labex.io/labs/linux-capture-release-headers-664827?course=100-days-of-linux-challenges">Capture Release Headers</a></li><li><a href="https://labex.io/labs/linux-download-the-release-artifact-664849?course=100-days-of-linux-challenges">Download the Release Artifact</a></li><li><a href="https://labex.io/labs/linux-verify-the-release-artifact-664916?course=100-days-of-linux-challenges">Verify the Release Artifact</a></li><li><a href="https://labex.io/labs/linux-close-the-app-validation-664838?course=100-days-of-linux-challenges">Close the App Validation</a></li></ol><h3>Days 61–70</h3><ol><li><a href="https://labex.io/labs/linux-locate-the-required-tool-664877?course=100-days-of-linux-challenges">Locate the Required Tool</a></li><li><a href="https://labex.io/labs/linux-discover-the-quiet-option-664848?course=100-days-of-linux-challenges">Discover the Quiet Option</a></li><li><a href="https://labex.io/labs/linux-install-the-missing-helper-664874?course=100-days-of-linux-challenges">Install the Missing Helper</a></li><li><a href="https://labex.io/labs/linux-verify-the-helper-version-664915?course=100-days-of-linux-challenges">Verify the Helper Version</a></li><li><a href="https://labex.io/labs/linux-use-the-installed-helper-664914?course=100-days-of-linux-challenges">Use the Installed Helper</a></li><li><a href="https://labex.io/labs/linux-check-the-tool-option-664833?course=100-days-of-linux-challenges">Check the Tool Option</a></li><li><a href="https://labex.io/labs/linux-find-the-provider-package-664858?course=100-days-of-linux-challenges">Find the Provider Package</a></li><li><a href="https://labex.io/labs/linux-pack-the-support-logs-664882?course=100-days-of-linux-challenges">Pack the Support Logs</a></li><li><a href="https://labex.io/labs/linux-unpack-the-support-bundle-664913?course=100-days-of-linux-challenges">Unpack the Support Bundle</a></li><li><a href="https://labex.io/labs/linux-close-the-support-bundle-664841?course=100-days-of-linux-challenges">Close the Support Bundle</a></li></ol><h3>Days 71–80</h3><ol><li><a href="https://labex.io/labs/linux-check-managed-service-state-664830?course=100-days-of-linux-challenges">Check Managed Service State</a></li><li><a href="https://labex.io/labs/linux-start-the-stopped-service-664908?course=100-days-of-linux-challenges">Start the Stopped Service</a></li><li><a href="https://labex.io/labs/linux-enable-the-service-for-boot-664850?course=100-days-of-linux-challenges">Enable the Service for Boot</a></li><li><a href="https://labex.io/labs/linux-apply-a-service-config-change-664821?course=100-days-of-linux-challenges">Apply a Service Config Change</a></li><li><a href="https://labex.io/labs/linux-find-the-service-error-664860?course=100-days-of-linux-challenges">Find the Service Error</a></li><li><a href="https://labex.io/labs/linux-repair-the-service-command-664895?course=100-days-of-linux-challenges">Repair the Service Command</a></li><li><a href="https://labex.io/labs/linux-prove-the-managed-endpoint-664886?course=100-days-of-linux-challenges">Prove the Managed Endpoint</a></li><li><a href="https://labex.io/labs/linux-schedule-the-maintenance-heartbeat-664904?course=100-days-of-linux-challenges">Schedule the Maintenance Heartbeat</a></li><li><a href="https://labex.io/labs/linux-fix-the-cron-path-664864?course=100-days-of-linux-challenges">Fix the Cron Path</a></li><li><a href="https://labex.io/labs/linux-rotate-the-application-log-664902?course=100-days-of-linux-challenges">Rotate the Application Log</a></li></ol><h3>Days 81–90</h3><ol><li><a href="https://labex.io/labs/linux-find-the-space-consumer-664861?course=100-days-of-linux-challenges">Find the Space Consumer</a></li><li><a href="https://labex.io/labs/linux-clean-only-safe-temp-files-664835?course=100-days-of-linux-challenges">Clean Only Safe Temp Files</a></li><li><a href="https://labex.io/labs/linux-add-the-compatibility-link-664819?course=100-days-of-linux-challenges">Add the Compatibility Link</a></li><li><a href="https://labex.io/labs/linux-repair-the-broken-link-664892?course=100-days-of-linux-challenges">Repair the Broken Link</a></li><li><a href="https://labex.io/labs/linux-back-up-before-the-change-664824?course=100-days-of-linux-challenges">Back Up Before the Change</a></li><li><a href="https://labex.io/labs/linux-restore-the-missing-file-664901?course=100-days-of-linux-challenges">Restore the Missing File</a></li><li><a href="https://labex.io/labs/linux-find-the-oversized-artifact-664857?course=100-days-of-linux-challenges">Find the Oversized Artifact</a></li><li><a href="https://labex.io/labs/linux-verify-the-restored-files-664917?course=100-days-of-linux-challenges">Verify the Restored Files</a></li><li><a href="https://labex.io/labs/linux-inspect-the-recovery-mounts-664872?course=100-days-of-linux-challenges">Inspect the Recovery Mounts</a></li><li><a href="https://labex.io/labs/linux-repair-the-persistent-mount-664894?course=100-days-of-linux-challenges">Repair the Persistent Mount</a></li></ol><h3>Days 91–100</h3><ol><li><a href="https://labex.io/labs/linux-restore-the-daily-export-664900?course=100-days-of-linux-challenges">Restore the Daily Export</a></li><li><a href="https://labex.io/labs/linux-recover-the-health-check-664889?course=100-days-of-linux-challenges">Recover the Health Check</a></li><li><a href="https://labex.io/labs/linux-restore-service-from-backup-664899?course=100-days-of-linux-challenges">Restore Service from Backup</a></li><li><a href="https://labex.io/labs/linux-unblock-the-deploy-script-664912?course=100-days-of-linux-challenges">Unblock the Deploy Script</a></li><li><a href="https://labex.io/labs/linux-fix-the-wrong-output-path-664866?course=100-days-of-linux-challenges">Fix the Wrong Output Path</a></li><li><a href="https://labex.io/labs/linux-repair-the-log-collector-664893?course=100-days-of-linux-challenges">Repair the Log Collector</a></li><li><a href="https://labex.io/labs/linux-secure-the-shared-dropbox-664905?course=100-days-of-linux-challenges">Secure the Shared Dropbox</a></li><li><a href="https://labex.io/labs/linux-restore-client-routing-664896?course=100-days-of-linux-challenges">Restore Client Routing</a></li><li><a href="https://labex.io/labs/linux-complete-the-ops-handoff-664844?course=100-days-of-linux-challenges">Complete the Ops Handoff</a></li><li><a href="https://labex.io/labs/close-the-broken-status-api-incident-664839?course=100-days-of-linux-challenges">Close the Broken Status API Incident</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=10e44942a210" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Don’t Have to Start Learning Linux by Installing an OS]]></title>
            <link>https://labexio.medium.com/you-dont-have-to-start-learning-linux-by-installing-an-os-8c03db49993d?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/8c03db49993d</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[linux-tutorial]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Thu, 02 Jul 2026 08:20:28 GMT</pubDate>
            <atom:updated>2026-07-02T08:20:28.785Z</atom:updated>
            <content:encoded><![CDATA[<h4>A Practical Guide for Beginners</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XEkrmnSoLmbvMcs2QPA9tw.jpeg" /></figure><p>Many people get stuck at the very first step of learning Linux: setting up the environment.</p><p>Installing Ubuntu, configuring WSL, setting up a virtual machine, buying a cloud server, connecting through SSH… These things are valuable in their own right. But for someone just starting with Linux, they can easily become unnecessary friction.</p><p>Before you even understand the terminal, file systems, permissions, or processes, you may already be dealing with graphics drivers, network issues, mirror sources, and virtual machine settings. That is enough to discourage many beginners.</p><p>A better order, in my view, is this: <strong>first enter a usable Linux environment and start practicing directly</strong>. Once you understand what you are doing in the terminal, you can go back and explore WSL, virtual machines, cloud servers, or your own Linux machine.</p><p>Hi, everyone. I’m Hang from LabEx. Today I’d like to share some Linux learning resources we have organized for beginners. Most of them are <strong>free</strong>.</p><p>This is not an article about “you must learn Linux through a specific platform.” It includes some learning resources provided by LabEx, but the main purpose is to give beginners a clear learning roadmap.</p><h3>1. The Hard Part of Learning Linux Is Not Really the Commands</h3><p>Many people think Linux is difficult because there are too many commands.</p><p>But what usually blocks beginners is not the complexity of a single command. It is the lack of a clear path. Today you read about ls, tomorrow you see grep, and the day after that you run into Docker, Kubernetes, Nginx, SSH, systemd, and iptables. Eventually, Linux starts to feel like a pile of disconnected topics.</p><p>A more reasonable learning order looks like this:</p><ol><li>First, understand the basic concepts in Linux.</li><li>Enter a terminal as early as possible and complete small tasks.</li><li>Practice the command line and file system systematically.</li><li>Learn Shell and start combining commands.</li><li>Understand users, permissions, processes, services, and logs.</li><li>Reinforce your knowledge through real scenarios.</li><li>Then move toward Git, Docker, DevOps, or cybersecurity depending on your goal.</li></ol><p>You do not need to pursue “complete understanding” from the beginning. For beginners, <strong>it is more important to complete a minimal learning path first</strong>.</p><h3>2. Read a Little, but Don’t Only Read</h3><p>If you have no Linux background at all, it is useful to start with a structured tutorial to build a basic mental model.</p><p>A good starting point is <a href="https://labex.io/linuxjourney"><strong>Linux Journey</strong></a>.</p><p>Linux Journey is a well-known free and open-source Linux beginner tutorial. It is suitable for understanding the basic structure of Linux, including the terminal, Shell, file systems, permissions, processes, package management, logs, and networking.</p><p>At this stage, you do not need to memorize everything. You only need to know what Linux is roughly made of. Later, as you practice, you will naturally encounter these topics again and again.</p><p>If you want to read additional external resources, these are also worth checking:</p><ul><li><a href="https://linuxcommand.org/tlcl.php">The Linux Command Line</a>: A free English book, suitable for learning the command line and Shell systematically. It is best read while practicing.</li><li><a href="https://ubuntu.com/tutorials/command-line-for-beginners">Ubuntu: Command line for beginners</a>: An official Ubuntu tutorial for people who are new to the terminal, WSL, or Ubuntu.</li><li><a href="https://developer.mozilla.org/en-US/docs/Learn_web_development/Getting_started/Environment_setup/Command_line">MDN: Command line crash course</a>: More suitable for developers, especially those with a web development background, who want to quickly understand the terminal and common commands.</li></ul><p>The role of reading is to <strong>build a map, not replace practice</strong>. Linux is ultimately learned in the terminal.</p><h3>3. Open a Real Terminal as Soon as Possible</h3><p><strong>Understanding command explanations and actually being able to use commands are two different things.</strong></p><p>You may understand what file permissions are in theory, but only after you create files, change permissions, switch users, and see errors yourself will you really understand why permissions affect program execution.</p><p>You may also understand what a pipe is conceptually, but only after you connect several commands to process text will you see why pipes are one of the most important ideas in the Linux command line.</p><p>If you do not want to set up an environment at the beginning, you can use LabEx’s free beginner course: <a href="https://labex.io/courses/quick-start-with-linux"><strong>Quick Start with Linux</strong></a>.</p><p>This course works well as a first hands-on course. It does not go very deep. Its main purpose is to help you quickly enter an operable Linux environment and complete basic exercises around files, permissions, and user management.</p><p>The key point here is not to “finish a course.” The key is to quickly develop a basic feeling: <strong>when you enter a command, the system state changes</strong>; when something goes wrong, the terminal gives you information about what happened.</p><h3>4. Learn the Command Line Through Tasks</h3><p>There are many Linux commands, but beginners should not try to memorize command lists.</p><p>A better method is to <strong>practice around tasks</strong>: find a file, inspect a log, search for a keyword, move a group of files, check system status, or see whether a port is occupied. Once the task is clear, the command becomes meaningful.</p><p>At this stage, focus on several types of skills:</p><ol><li>Working with files and directories.</li><li>Viewing file contents.</li><li>Searching files and text.</li><li>Processing text.</li><li>Using pipes and redirection.</li><li>Checking system information.</li><li>Using basic networking commands.</li><li>Looking up help and documentation.</li></ol><p>LabEx’s <a href="https://labex.io/courses/linux-basic-commands-practice-online"><strong>Linux Basic Commands Practice Online</strong></a> fits well at this stage.</p><p>It is more like command-line fundamentals training, not an advanced system administration course. After you have read some basic concepts, it helps you become familiar with common commands through practice.</p><p>Two tools are also useful when practicing commands:</p><ul><li><a href="https://tldr.sh/">tldr pages</a>: Shorter than man, useful for quickly checking common command examples.</li><li><a href="https://explainshell.com/">ExplainShell</a>: Breaks down a Shell command and explains each part. Useful when you cannot understand a complex command.</li></ul><p>Do not rush to measure “how many commands you know.” What matters more is this: when you encounter a problem, you roughly know <strong>what to search for, what to try, and how to verify the result</strong>.</p><h3>5. Shell Is the Bridge from Usage to Automation</h3><p>Once you are comfortable with some basic commands, you can start learning Shell.</p><p>The value of Shell is not just “writing scripts.” More importantly, it helps you <strong>connect scattered commands together</strong> so you can process files in batches, analyze logs, check system status, or turn repeated operations into reusable small tools.</p><p>At this stage, focus on:</p><ol><li>Variables.</li><li>Arguments.</li><li>Conditional statements.</li><li>Loops.</li><li>Functions.</li><li>Exit status.</li><li>Environment variables.</li><li>Pipes and redirection.</li><li>Simple automation scripts.</li></ol><p>LabEx provides a <a href="https://labex.io/learn/shell">Shell learning path</a>, as well as a beginner-friendly course: <a href="https://labex.io/courses/shell-for-beginners"><strong>Shell for Beginners</strong></a>.</p><p>For beginners, there is no need to dive into every corner case of Bash syntax at the start. Being able to turn repeated operations into a script is already a major step forward.</p><p>If you want to look up more detailed Shell behavior, these references are useful:</p><ul><li><a href="https://www.gnu.org/software/bash/manual/bash.html">Bash Reference Manual</a>: The official Bash manual. Good for checking syntax details, but not suitable as a zero-to-one beginner tutorial.</li><li><a href="https://www.shellcheck.net/">ShellCheck</a>: Checks common issues in Shell scripts. Very useful when writing scripts.</li></ul><h3>6. System Administration Basics Decide Whether You Can Use Linux for Real Work</h3><p>After learning commands and Shell, you can start filling in the basics of system administration.</p><p>This step gets closer to servers and real-world work scenarios:</p><ol><li>Users and groups.</li><li>File permissions.</li><li>sudo and root.</li><li>Process management.</li><li>Service management.</li><li>Package management.</li><li>Disks and file systems.</li><li>Reading logs.</li><li>Basic network troubleshooting.</li><li>SSH remote access.</li></ol><p>These topics are not only for operations engineers. Developers also encounter them repeatedly when deploying services, debugging production issues, using Docker, configuring CI/CD, and analyzing logs.</p><p>LabEx’s <a href="https://labex.io/learn/linux"><strong>Linux learning path</strong></a> can be used as the main route. If you want something closer to junior-level system administration tasks, you can also look at <a href="https://labex.io/courses/become-a-junior-system-administrator">Become a Junior System Administrator</a>.</p><p>If you want to continue learning system administration, these resources are also useful:</p><ul><li><a href="https://debian-handbook.info/">Debian Administrator’s Handbook</a>: Good for understanding Debian / Ubuntu-based Linux system administration.</li><li><a href="https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/">Red Hat Enterprise Linux Documentation</a>: Useful for learning RHEL, RHCSA, and enterprise Linux environments.</li></ul><p>At this stage, do not only read concepts. Users, permissions, services, and logs only become real experience when you repeatedly encounter them in actual tasks.</p><h3>7. Use Scenarios to Connect the Knowledge</h3><p>One of the most common problems in learning Linux is this: <strong>each topic seems understandable on its own, but when faced with a real task, you do not know where to start</strong>.</p><p>That is why, after the basics, you should do more scenario-based practice. For example:</p><ol><li>Fix a permission issue.</li><li>Find abnormal logs.</li><li>Check service status.</li><li>Clean up disk space.</li><li>Troubleshoot port usage.</li><li>Manage users and files.</li><li>Write a simple automation script.</li><li>Complete a small system administration task.</li></ol><p>LabEx has a free <a href="https://labex.io/courses/100-days-of-linux-challenges"><strong>100 Days of Linux Challenges</strong></a>.</p><p>The idea is to complete one small task each day, gradually moving from basic commands to system administration, permissions, processes, package management, services, storage, logs, networking, and more. You do not have to do it every day, but it can serve as a long-term way to check whether you can really use Linux.</p><p>There is also <a href="https://labex.io/courses/linux-practice-challenges">Linux Practice Challenges</a>, which is suitable for people who have already learned the basics and want to further strengthen command-line, Shell, and system administration skills.</p><p>If you want practice resources outside LabEx, you can also try:</p><ul><li><a href="https://overthewire.org/wargames/bandit/">OverTheWire Bandit</a>: A classic command-line and security fundamentals practice site. It is better to try it after you know a little Linux.</li><li><a href="https://linuxsurvival.com/">Linux Survival</a>: An old-school interactive Linux command practice site, useful as a beginner supplement.</li></ul><h3>8. A Stable Learning Order</h3><p>If you have no idea where to start, you can follow this order:</p><ol><li>First read <a href="https://labex.io/linuxjourney"><strong>Linux Journey</strong></a> to build basic concepts.</li><li>Take <a href="https://labex.io/courses/quick-start-with-linux"><strong>Quick Start with Linux</strong></a> to enter a real terminal environment.</li><li>Practice with <a href="https://labex.io/courses/linux-basic-commands-practice-online"><strong>Linux Basic Commands Practice Online</strong></a> to become familiar with common commands.</li><li>Learn <a href="https://labex.io/courses/shell-for-beginners"><strong>Shell for Beginners</strong></a> to understand scripting and automation.</li><li>Continue with the <a href="https://labex.io/learn/linux"><strong>Linux learning path</strong></a> to fill in system administration basics.</li><li>Do <a href="https://labex.io/courses/100-days-of-linux-challenges"><strong>100 Days of Linux Challenges</strong></a> to keep practicing through real scenarios.</li><li>Depending on your goal, continue toward <a href="https://labex.io/skilltrees"><strong>Git, Docker, DevOps, cybersecurity, or certification paths</strong></a>.</li></ol><p>This is not the only possible order, but for beginners, it is clear enough and avoids too many branches at the beginning.</p><h3>9. Where to Go After Linux</h3><p>Linux is the foundation of many technical directions, but that does not mean you need to learn everything from the start. Build a solid foundation first, then choose your next path based on your goal.</p><p>If you want to do software development, continue with Git. It is almost essential in modern development. After learning Linux basics, learning Git feels natural. You can look at LabEx’s <a href="https://labex.io/learn/git">Git learning path</a> and <a href="https://labex.io/courses/git-for-beginners">Git for Beginners</a>.</p><p>If you want to work on backend development, operations, or DevOps, continue with Docker. Images, processes, file systems, networking, mounts, and permissions in containers are all connected to Linux fundamentals. You can start with the <a href="https://labex.io/learn/docker">Docker learning path</a> and <a href="https://labex.io/courses/docker-for-beginners">Docker for Beginners</a>.</p><p>If you want to move further into DevOps, do not rush into Kubernetes at the very beginning. A more natural order is <strong>Linux, Shell, Git, Docker, CI/CD, Kubernetes</strong>, and then tools like Ansible, Jenkins, Terraform, and Monitoring.</p><p>You can refer to LabEx’s <a href="https://labex.io/learn/devops">DevOps learning path</a> and <a href="https://labex.io/learn/devops-engineer">DevOps Engineer path</a>. Related resources include the <a href="https://labex.io/learn/kubernetes">Kubernetes learning path</a>, <a href="https://labex.io/courses/kubernetes-for-beginners">Kubernetes for Beginners</a>, <a href="https://labex.io/learn/ansible">Ansible learning path</a>, and <a href="https://labex.io/learn/jenkins">Jenkins learning path</a>.</p><p>If you want to move into cybersecurity, Linux fundamentals are also essential. Many security tools are just the surface. What you really need to understand is the system, network, permissions, processes, logs, and files. You can continue with <a href="https://labex.io/learn/cybersecurity">Cybersecurity</a>, <a href="https://labex.io/learn/kali">Kali Linux</a>, <a href="https://labex.io/learn/nmap">Nmap</a>, <a href="https://labex.io/learn/wireshark">Wireshark</a>, and <a href="https://labex.io/courses/linux-security-for-devsecops">Linux Security Practices for DevSecOps</a>.</p><p>If you need a clear goal, you can also consider a certification path. Certificates are not required, but they help narrow the learning scope. For Linux-related certifications, you can look at <a href="https://labex.io/learn/lfcs">LFCS Training</a>, <a href="https://labex.io/learn/rhcsa">RHCSA Training</a>, <a href="https://labex.io/learn/rhel">Red Hat Enterprise Linux</a>, and <a href="https://labex.io/courses/comptia-linux-plus-training-labs">CompTIA Linux+ Certification Training Labs</a>. For Kubernetes, there are <a href="https://labex.io/learn/cka">CKA Training</a>, <a href="https://labex.io/learn/ckad">CKAD Training</a>, and <a href="https://labex.io/learn/cks">CKS Training</a>.</p><p>Certification paths are better used after you already have some foundation and want to test your ability. I do not recommend starting with certification practice from zero.</p><p>When you encounter specific issues later, official documentation and reference manuals are also worth checking:</p><ul><li><a href="https://wiki.archlinux.org/">Arch Wiki</a>: Very information-dense. Great as a reference, but not something beginners should read from beginning to end.</li><li><a href="https://man7.org/linux/man-pages/">man7.org</a>: Online Linux man pages, useful for checking commands, system calls, and low-level behavior.</li><li><a href="https://www.gnu.org/software/coreutils/manual/">GNU Coreutils Manual</a>: Useful if you want to understand common basic commands in more depth.</li></ul><h3>10. A Few Practical Suggestions</h3><p>Do not spend too much time worrying about the distribution at the beginning. Ubuntu, Debian, Fedora, Arch, and RHEL can all be used to learn Linux. At the beginner stage, what matters more is the common foundation: command line, file systems, permissions, processes, services, and networking.</p><p>Do not memorize commands mechanically. Learn commands through tasks, look them up when needed, and they will gradually become familiar through repeated use.</p><p>Do not only watch videos or read articles. Linux is ultimately learned in the terminal. Even a short daily practice session is more useful than watching tutorials for hours without touching a real environment.</p><p>When you see an error, try to read the error message first. Permission denied, file not found, command not found, port already in use, service not started — these are all very common problems.</p><p>It is also useful to start keeping your own notes early. You do not need to write long tutorials. Just record common commands, typical errors, solutions, and the problems you personally ran into.</p><p>One thing we have learned while building LabEx is that the real difficulty of learning Linux is not that a certain command is especially complex. The bigger problem is often the lack of a clear path and the lack of an environment where beginners can keep practicing.</p><p>I hope this roadmap helps new Linux learners avoid some unnecessary detours. If you know other resources that are especially suitable for beginners, feel free to share them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8c03db49993d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Linux Journey Is Now Part of LabEx]]></title>
            <link>https://labexio.medium.com/linux-journey-is-now-part-of-labex-be46c7a5e416?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/be46c7a5e416</guid>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[linux-journey]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 10:44:11 GMT</pubDate>
            <atom:updated>2026-06-12T10:44:11.325Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e3z_AcLKBXWQduaaMpmLYA.avif" /></figure><p>Linux Journey has been one of the most popular free resources for learning Linux since 2015.</p><p>Created by Cindy Quach, the project has helped millions of beginners take their first steps into Linux through simple lessons and quizzes.</p><p>Today, Linux Journey is officially part of LabEx.</p><p>The original Linux Journey website (<a href="https://linuxjourney.com/">https://linuxjourney.com</a>) now redirects to <a href="https://labex.io/linuxjourney">https://labex.io/linuxjourney</a>.</p><p>Our goal is straightforward: keep Linux Journey free, open source, and actively maintained for the next generation of Linux learners.</p><p>We’ll continue maintaining existing lessons, fixing issues, improving translations, and adding new beginner-friendly content over time.</p><p>The official repository is now maintained by the LabEx team:</p><p><a href="https://github.com/labex-labs/linuxjourney">https://github.com/labex-labs/linuxjourney</a></p><p>We’ve also recently launched the Linux Journey iOS app, making it easier to learn Linux on the go:</p><p><a href="https://apps.apple.com/app/linux-journey/id6770861660">https://apps.apple.com/app/linux-journey/id6770861660</a></p><p>Most importantly, nothing changes about what made Linux Journey special.</p><p>It remains free. It remains open source. It remains community-driven.</p><p>A huge thank you to Cindy Quach and all contributors who helped build Linux Journey into one of the most loved Linux learning resources on the internet.</p><p>We’re honored to continue the journey.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be46c7a5e416" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LabEx Challenges: LeetCode for Linux]]></title>
            <link>https://labexio.medium.com/labex-challenges-leetcode-for-linux-1e28957defea?source=rss-991c67b047ab------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e28957defea</guid>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[leetcode]]></category>
            <dc:creator><![CDATA[LabEx]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 10:42:00 GMT</pubDate>
            <atom:updated>2026-06-12T10:42:00.246Z</atom:updated>
            <content:encoded><![CDATA[<p>We recently launched a new Challenges page for LabEx:</p><p><a href="https://labex.io/challenges">https://labex.io/challenges</a></p><p>The goal is to make Linux practice more structured, measurable, and closer to real-world problem solving.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*msOyP4Dpwka-g8-1D4aM8Q.png" /></figure><p>For many learners, Linux education usually starts with tutorials, documentation, or guided labs. These are useful for building familiarity, but they do not always answer a more practical question: can the learner solve a problem independently in a real terminal?</p><p>That is the gap LabEx Challenges is designed to address.</p><p>Each challenge runs in a real hands-on environment. Users are given a task, a system state, and a set of checks. They need to inspect files, run commands, debug issues, configure services, or fix broken systems. Instead of choosing an answer, they have to make the environment pass verification.</p><p>In that sense, the experience is closer to coding challenge platforms, but focused on Linux and infrastructure skills. Think of it as LeetCode for Linux.</p><p>The new Challenges page brings these exercises together in one place, including collections for Linux, Docker, Kubernetes, DevOps, Cybersecurity, and more. Some challenges focus on basic command-line usage, while others simulate operational tasks that are closer to what users may face in production environments.</p><p>Our broader idea is simple: guided labs are good for learning new concepts, while challenges are better for testing whether those concepts can be applied without step-by-step instructions.</p><p>Learn in Labs. Prove it in Challenges.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e28957defea" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>