#cli (79)
- Setting Up Your Python Playground
Learn how to set up your Python development environment with VS Code and the terminal.
- Setting Up Dolt and Your First Data Commit
Learn to install Dolt, initialize your first version-controlled SQL database, and make your initial data commit, understanding the core Git-for-Data paradigm.
- Integrate AI into Your Terminal with omp.sh
Readers will learn how to integrate omp.sh, an AI coding agent, into their terminal workflow to generate, modify, and debug code efficiently.
- Reduce Context Switching with omp.sh AI Terminal Assistant
Install and configure omp.sh, an AI terminal assistant, to reduce context switching and boost efficiency in your daily coding workflow.
- Install omp.sh and Configure AI Provider API Keys
You will install the omp.sh AI coding agent and securely configure its essential AI provider API keys to enable AI assistance.
- Strategic Problem-Solving: Leveraging Plan Mode and Goal Mode
Master strategic problem-solving with omp.sh's Plan Mode and Goal Mode, guiding AI agents through complex coding tasks with structured plans and iterative goal-setting.
- Your First AI-Powered Coding Steps: Core Agent Commands
Discover the power of omp.sh by learning its core commands and how to integrate AI directly into your terminal-based coding workflow for enhanced productivity.
- Collaborative Intelligence: Subagents and Hindsight Memory
Explore how omp.sh leverages collaborative intelligence through subagent-like workflows and learns from past interactions with hindsight memory, enhancing problem-solving in your terminal.
- Mastering omp.sh Best Practices and AI Agent Comparison
Discover omp.sh best practices, understand its limitations, and compare it to other AI coding agents to optimize your development workflow.
- Jujutsu: Your First Repository and the Working Copy Commit
Learn to create your first Jujutsu repository and grasp its core 'working copy as a commit' model to effectively manage changes and prepare for advanced workflows.
- Learn Revsets for Precise Commit Navigation in Jujutsu
Learn Revsets to query, filter, and combine commits in Jujutsu, enabling precise history navigation and efficient mutable history management.
- Customize Jujutsu (jj) for a Personalized Developer Workflow
Customize Jujutsu with configuration files, powerful aliases, and editor integrations to streamline your daily development workflow and enhance productivity.
- Welcome to AIPack: Your Agentic Runtime for AI
Discover AIPack, an open-source agentic runtime for building, running, and sharing AI agents. Learn installation, core concepts, and create your first agent.
- Set Up Your AIPack AI Agent Development Environment
Readers will learn to configure their system with Python, AIPack CLI, Ollama, and VS Code, enabling efficient development of AI agents.
- Kickstarting Modern Angular with Standalone Apps
Begin your Angular mastery journey by setting up your development environment and creating your first modern Angular standalone application, leveraging AI for initial setup.
- Kickstarting Modern Angular with Standalone Apps
Begin your Angular mastery journey by setting up your development environment and creating your first modern Angular standalone application, leveraging AI for initial setup.
- 10 Command-Line Apps to Boost Ubuntu Productivity
Learn 10 powerful command-line applications to significantly enhance your productivity and transform your Ubuntu terminal into an efficient workspace.
- CLI-First AI Systems: Terminal Agents and Automation
Learn to integrate AI agents directly into your terminal workflows, automating command-line tasks, enhancing developer processes, and orchestrating multi-agent systems.
- AI Agents for Smarter Development, Debugging & Scripting
Learn to integrate AI agents into your development workflow to automate commands, create dynamic scripts, and enhance debugging in your terminal.
- Beyond Chat: Automating Terminal Tasks with AI Agents
Move beyond conversational AI to automate complex terminal tasks with AI agents. Learn about command generation, shell tool integration, and AI-discoverable skills.
- Talking to AI: Your First Steps with a CLI Agent (e.g., Gemini CLI)
Take your first steps with a CLI-first AI agent like Gemini CLI. Learn to install, configure, and interact with AI directly from your terminal for command generation and task automation.
- Connect AI Agents to Shell Tools for Powerful CLI Automation
Learn to integrate AI agents with your existing shell tools to create powerful command-line automation and enhance your developer workflows.
- CLI-First AI Systems: A Developer's Guide
Explore CLI-first AI systems, learning how AI agents integrate with terminal environments for automation, scripting, and enhanced developer workflows. Discover practical examples.
- Orchestrate Multi-Agent AI Workflows and Discoverable CLI Skills
Learn to coordinate multiple AI agents for complex tasks and define AI-discoverable skills that empower them to utilize existing command-line tools effectively.
- Get Started with CLI-First AI Agents in Your Terminal
Learn to integrate AI agents directly into your terminal to automate commands, streamline scripting, and enhance developer workflows with practical examples.
- Build a Production-Ready Rust CLI: Arguments, Files, Errors
Master building production-ready Rust CLI applications by implementing argument parsing, file I/O, and robust error handling for dependable tools.
- Ratatui Practical Field Guide
Embark on a comprehensive journey to master Ratatui, the powerful Rust library for building interactive terminal user interfaces, from the ground up.
- Building MermaidLint: A Production-Grade Mermaid Analyzer & Fixer
Learn to build a strict, production-grade Mermaid code analyzer and fixer in Rust, from scratch to deployment, with compiler-level rigor.
- Designing and Implementing a Rust CLI: UI and Output Modes
Learn to build a robust Rust CLI for a Mermaid analyzer, implementing argument parsing, multiple output modes, and clear terminal diagnostics.
- Harden Rust CLI Tools: Input Validation & Supply Chain Security
Learn to secure Rust CLI applications by implementing strict input validation, managing resource consumption, and ensuring supply chain integrity against various attacks.
- Automate Rust CLI CI/CD with GitHub Actions and Docker
You will learn to automate Rust CLI build, test, and release processes using GitHub Actions and Docker for secure, efficient deployment.
- Terminal User Interfaces: Build Your First Rust TUI Application
Understand Terminal User Interfaces, their distinctions from CLIs and GUIs, and build your first interactive terminal app using Rust and Ratatui.
- Setting Up Your First Ratatui Project
Get started with Ratatui! This chapter guides you through setting up your first Rust TUI project, adding dependencies, and displaying a basic 'Hello, TUI!' message.
- The Basic Ratatui Loop: Drawing Your First Frame
Dive into the core of Ratatui by learning how to set up the main drawing loop and render your very first text-based frame in a Rust TUI application.
- Widgets: Building Blocks of Your UI
Explore Ratatui widgets: the fundamental building blocks for creating interactive terminal user interfaces. Learn to use Block and Paragraph to structure and display content.
- Layout Management: Arranging Your Widgets
Master Ratatui's layout system to arrange widgets effectively. Learn about Directions, Constraints, and nesting layouts to build structured terminal UIs.
- Event Handling: User Input and Interaction
Learn how to make your Ratatui TUI applications interactive by handling user input and events with crossterm, including keyboard and terminal resize events.
- State Management: Making Your UI Dynamic
Learn how to manage application state in Ratatui using the Model-View-Update pattern, enabling dynamic and interactive terminal user interfaces with practical examples.
- Custom Widgets: Extending Ratatui
Dive into creating custom Ratatui widgets to build unique and highly interactive terminal user interfaces in Rust, going beyond built-in components.
- Build Responsive Ratatui TUIs with Async & Concurrency
Implement asynchronous operations and concurrency in Ratatui TUIs to create responsive interfaces for background tasks, non-blocking I/O, and inter-task communication.
- Handle Mouse Events, Resizes, and Modals in Ratatui TUIs
After this chapter, you can implement advanced event handling, including mouse and resize events, and build interactive modal dialogs for Ratatui applications.
- Styling and Theming Ratatui Terminal User Interfaces
Readers will learn to apply custom styles, colors, and text modifiers to Ratatui TUIs, creating visually appealing and user-friendly applications.
- Optimize Ratatui Performance for Complex Terminal UIs
Learn to optimize Ratatui applications by minimizing redraws, handling events efficiently, and managing state for responsive terminal UIs.
- Project: Creating a File Browser
Build a practical terminal file browser application using Ratatui, learning advanced TUI patterns like state management, directory listing, and interactive navigation.
- Project: Building a Simple Task Manager
Build a practical terminal task manager using Ratatui, applying state management, event handling, and UI rendering techniques to create an interactive TUI application.
- Project: Developing a Monitoring Dashboard
Build a practical terminal-based system monitoring dashboard using Ratatui. Learn to integrate system metrics, manage UI layouts, and handle real-time data updates.
- Error Handling and Robustness
Learn robust error handling techniques in Ratatui applications, including graceful shutdowns, custom error types, and using `anyhow` for production-grade TUIs.
- Testing Your Ratatui Applications
Master testing strategies for your Ratatui applications, including unit, integration, and snapshot testing, to build robust and reliable terminal user interfaces.
- Deployment and Distribution
Learn how to package and distribute your Ratatui applications for various platforms, including cross-compilation and release management, ensuring users can easily run your TUI.
- Structure Scalable Ratatui Applications with Elm Architecture
Learn to apply the Elm Architecture to structure scalable and maintainable Ratatui applications, effectively managing state and handling user events in Rust.
- Craft Powerful Terminal UIs in Rust with Ratatui
Elevate your skills in building robust and visually appealing terminal user interfaces with Rust, applying Ratatui from fundamental concepts to advanced techniques.
- Set Up Your First SpaceTimeDB Project and Backend Logic
You will learn to install the SpaceTimeDB CLI, set up a project, define a database schema, write reducers, and run your instance locally.
- 3. Your First Void Cloud Project: Hello World
Deploy your very first 'Hello World' application on Void Cloud. Learn to initialize a project, understand the basic deployment workflow, and see your code live on the cloud.
- Develop and Deploy Void Cloud Applications from Local to Cloud
Configure your local development environment, deploy applications with the Void CLI, and manage secrets for production-ready Void Cloud deployments.
- Set Up Void Cloud Account, Install CLI, and Authenticate
Create your Void Cloud account, install the command line interface, and authenticate your session to prepare for application deployment.
- Implement CLI and Configuration for Rust SSG
Learn to implement a command-line interface and robust configuration management for a Rust static site generator using `clap`, `serde`, and `toml`.
- Build a Swift Command-Line Tool with ArgumentParser
Readers will learn to build functional Swift command-line tools using Swift Package Manager and effectively parse arguments with ArgumentParser.
- Getting Started with Apple Containers
Dive into Apple's native Linux container tools for Mac. Learn to install, understand core concepts, and run your first container with practical, step-by-step guidance.
- Basic Container Operations: Run, Stop, Remove
Master the essential commands to run, stop, and remove Linux containers on your Mac using Apple's native container tools. Learn about container lifecycle and port mapping.
- Networking and Port Mapping for Containers
Master networking and port mapping for Linux containers on your Mac using Apple's container CLI. Learn to expose container services to your host for seamless access.
- Your First Compression: Basic Usage & Concepts
Learn how to use OpenZL for data compression, understanding core concepts like Codec Graphs and Compression Plans.
- Linux Fundamentals - Your First Steps in the Server World
Learn the basics of Linux and the command line interface to become a DevOps engineer.
- Configure Your Puter.js Development Environment
You will install Node.js and npm, configure your Puter.js development environment, and successfully run your very first application.
- Trackio CLI: Manage ML Experiments, Dashboards, and Sync
You will use Trackio's command line interface to efficiently manage machine learning experiments, launch dashboards, and integrate with cloud platforms.
- Sed Text Manipulation: Substitution and Filtering
Learn to efficiently manipulate text files in Linux using sed, covering essential commands for substitution, filtering, and deleting lines based on patterns.
- Find Command Mastery - Linux File Search Essentials
Learn how to use the powerful `find` command in Linux for efficient file and directory searches.
- The Absolute Basics of Version Control and Git
Learn the basics of version control and Git, including setting up a local repository and performing basic operations.
- Install Git, Configure It, and Create Your First Repository
You will install Git, configure your user identity, and initialize your first local repository to establish your essential version control workflow.
- Setting Sail - Installing Docker & Your First Container
Learn to install Docker and run your first container with step-by-step instructions.
- Tic-Tac-Toe Game: Object-Oriented Design & Game State
Learn to build a Tic-Tac-Toe game using Object-Oriented Design principles in Java.
- Setting Up Rust and Your Project
Learn how to set up your Rust development environment and initialize a new project for building a password generator CLI application.
- Defining CLI Flags with Clap
Learn how to define CLI flags with Clap in Rust for a customizable password generator.
- Handling Multiple Passwords
Learn how to extend a CLI tool to generate multiple passwords with customizable options.
- Logging and Debug Output
Learn how to add logging and debug output to your Rust application using the `env_logger` crate.
- Using Command-Line Arguments and Environment Variables in C
Write flexible C programs by parsing command-line arguments and utilizing environment variables for runtime configuration and system integration.
- Guided Project: Simple Command-Line Calculator
Learn to build a simple command-line calculator in C, applying functions, control flow, and data types.
- Build a Command-Line Todo Application in Rust
Build a functional command-line todo application in Rust, mastering data structures, ownership, error handling, and JSON file I/O for persistent data storage.
- AI-Powered Development Tools: Angular MCP Server
Learn about the Angular MCP Server and how it leverages AI to enhance your development workflow.
- Learn linux in 100 days
A comprehensive 100-day guide to mastering Linux, from basics to advanced topics.