DEV Community: Vladislav Guzey

Build Your First AI Agent with Google CLI (Step-by-Step)

Vladislav Guzey — Wed, 29 Apr 2026 14:27:17 +0000

Vladislav Guzey

Apr 29

What is Google Agents CLI? Full Beginner Guide

#ai #google #googlecloud #tutorial

Comments 1

5 min read

What is Google Agents CLI? Full Beginner Guide

Vladislav Guzey — Wed, 29 Apr 2026 14:26:11 +0000

Google recently released the Agentic CLI, a powerful tool that makes building, testing, and deploying AI agents faster and more intuitive. I think it’s super useful, so I'll walk you through the entire lifecycle of an AI agent using the CLI.

What is the Google Agents CLI?

Before we dive into the code, let’s understand the “why.” Usually, building an AI agent requires a lot of “glue code”, the messy scripts that connect an LLM (Large Language Model) to external tools or databases.

The Agents CLI removes this friction. Agents CLI is an official Google tool for creating, evaluating, and deploying agents built with Google’s Agent Development Kit (ADK). It acts as the programmatic backbone of the Agent Development Lifecycle (ADLC) on Google Cloud.

Skills packaged for agents

Agents CLI bundles seven “skills” that teach coding agents how to perform each step of the ADLC:

Your coding agent can call these skills directly once installed. Alternatively, a human developer can run the same commands manually (see “Human Mode” below).

How to Install Google Agents CLI?

To get started, you need a clean environment. The CLI relies on a few modern web and data tools. Follow these steps to ensure everything is ready:

Prerequisites

Python & PIP: The backbone of most AI development.

sudo apt install python3 python3-pip

Node.js & NPM: Required for the CLI’s interface and deployment features.

sudo apt install nodejs npm

UV: A lightning-fast Python package installer that the Agents CLI uses under the hood.

pip install uv

Installation Steps

Create a Virtual Environment: It is always a good idea to keep your projects separate so they don’t interfere with each other.

python -m venv agent-env  
source agent-env/bin/activate  # On Windows use `agent-env\Scripts\activate`

The CLI is distributed through uv:

uvx google-agents-cli setup

The CLI supports macOS and Linux; native Windows is currently unsupported (use WSL 2 instead).

Authentication

Agents CLI picks up your credentials automatically if you are already authenticated with the gcloud CLI. When running locally without gcloud, you can set a Gemini API key:

export GEMINI_API_KEY="your‑key"

For detailed authentication scenarios (service accounts, A2A roles etc.) refer to the Authentication guide. The important point is that your coding agent inherits whatever credentials your shell has; you do not need to embed secrets in code.

Building Your First “Weather” Agent

The fastest way to learn is by doing. The CLI comes with a “boilerplate” or template system to get you moving in seconds.

Run the following command in your terminal:

agent-cli create my-first-agent  
cd my-first-agent

Install Dependencies

Inside your new project folder, you need to install the specific libraries required for this agent:

agent-cli install

The Playground

One of the best features of this CLI is the Playground. Instead of testing your agent in a black-and-white terminal, you can launch a local web interface.

agent-cli playground

Once you run this, you’ll get a local URL (usually http://127.0.0.1:8000). Open it in your browser, select your agent from the menu, and start chatting. By default, this agent is configured to handle weather requests.

When you are ready to evaluate, call:

agents-cli eval run

Deploy AI Agents

When you run agent-cli deploy, you usually have two choices:

Cloud Run: This treats your agent like a standard web application. It’s great if you want total control over the server.
Agent Runtime: This is a specialized environment built specifically for AI. It handles things like Memory (remembering what the user said earlier) and Orchestration (managing multiple agents working together) automatically.

The Deployment Process

Ensure you have a Google Cloud Project set up.
Enable billing in the Cloud Console.
Run the command:

# Deploy to the configured target (Agent Runtime, Cloud Run or GKE)  
agents-cli deploy

If you want to register your agent with Gemini Enterprise, run this command:

# Register your deployed agent with Gemini Enterprise  
agents-cli publish gemini-enterprise

It allows you to use your agent directly from https://gemini.google.com/

Almost all commands accept flags such as --project, --region, --datastore, --cicd-runner and --deployment-target so that you can customize the environment. Use agents-cli --help the CLI reference for full details.

Agents CLI Key Commands Cheat Sheet

agent-cli setup Installs the core environment
agent-cli create [name] Starts a new agent project
agent-cli playground Launches the web testing interface
agent-cli eval run Checks if your agent is performing correctly
agent-cli deploy Pushes your agent to Google Cloud

Building an agent with your coding assistant

After installation, open your coding assistant (Codex, Claude Code, Gemini CLI, or Copilot) and verify that the Agents CLI skills are visible:

/skills

You should see google‑agents‑cli‑workflow and the other packaged skills. From there, you can instruct the agent using natural language. For example:

Build a support agent that answers questions from our docs

Gemini CLI (or Claude Code, Codex, etc.) will call the CLI skills to scaffold the project, install dependencies, evaluate performance, and prepare deployment. This pattern works with any agent platform that supports skills installation.

If you're happy with the result, simply call deploy command and your agent will be live:

# Deploy to the configured target (Agent Runtime, Cloud Run or GKE)  
agents-cli deploy

Video Tutorial: Agents CLI Explained

In this video, I’ll show you how to use Google Agents CLI to build, test, and deploy AI agents from scratch.

Watch on YouTube: Agents CLI Explained

Conclusion

Google’s new agent‑oriented CLIs demonstrate how the command line is becoming a universal interface for both human operators and AI agents. Agents CLI offers a comprehensive, officially supported pathway to turn ideas into production‑ready agents on Google Cloud.

Give it a shot and share with me what you build!

Cheers, proflead! ;)

GitHub Copilot AI Agents: The Complete Technical Deep Dive

Vladislav Guzey — Sun, 19 Apr 2026 15:07:53 +0000

Vladislav Guzey

Apr 19

GitHub Copilot AI Agents: The Secret to 10x Engineering in 2026

Comments

4 min read

GitHub Copilot AI Agents: The Secret to 10x Engineering in 2026

Vladislav Guzey — Sun, 19 Apr 2026 15:07:17 +0000

In this article, I’ll show you how to unlock the full power of GitHub Copilot agents inside VS Code. There are actually three main types of Copilot agents-most people only know about one, but I’m going to show you all of them. By the end, you’ll be able to create custom agents that act as your own specialized “sub-agents.”

Getting Started: The Setup

Before we dive into the agents, make sure your environment is ready.

Update VS Code: Ensure you are on the latest version.
Enable Agent Settings: Go to your VS Code settings and search for “chat agent.” You should enable:

Third-party coding agents
Background agents
Cloud agents
Agent skills

I also recommend enabling the “integrated browser agent tool.” Even though I won’t deep-dive into it here, it allows your agents to browse the web to find documentation or test your UI.

What are GitHub Copilot Agents?

An agent is different from a standard LLM chat. While a chat answers questions, an agent uses tools to perform actions.

Autonomy: They can search your codebase, read files, and (in some modes) edit code or run terminal commands.
Context-Awareness: They don’t just see the snippet you’re looking at; they can “walk” the file tree to understand dependencies.
The “Brain”: Powered by high-reasoning models like Claude 4.7 Sonnet or GPT-5.4.

The 3 Types of Copilot Agents

Once your settings are enabled, you’ll see a dropdown in the chat window.

There are three primary categories:

1. Local Agents

These run interactively inside VS Code. They have “strong workspace awareness,” meaning they know exactly what files you have open.

Best for: Brainstorming, understanding a codebase, and running multiple sessions with different models to see which one gives the best answer.

2. Background Agents (Copilot CLI)

These are autonomous. They run on your machine in the background while you keep working on other things.

Best for: Executing a well-defined plan or fixing a specific bug on a different branch while you stay focused on your main task.

3. Cloud Agents

These run remotely on GitHub’s servers.

Best for: Collaboration. You can start a task, close your laptop, and your teammate can pick it up from another computer. It keeps your local environment free.

Building Your Own Custom Agent

If you want to move beyond the general assistant, you can create Custom Agents. Think of these as specialists-you could have a “Front-End Expert,” a “Doc Writer,” or a “Code Reviewer.”

Custom agents are defined by a .agent.md file. This is a Markdown file with a YAML header that acts as the "DNA" of your agent.

Where to put the file:

Project Level: .github/agents/my-agent.agent.md (Shared with the team).
User Level: ~/.copilot/agents/my-agent.agent.md (Personal use).

How to create one:

Open the agent dropdown in the bottom right corner of the chat.

Select “Create New Sub Agent.”

You can either write it from scratch or let Copilot generate a template for you.
You’ll get a simple file (often in .mdx or .yml format). Here, you define:

The Role: Who is this agent?
The Tools: What can it access?
Instructions: Specific rules it must follow.

The Anatomy of .agent.md

---  
name: Security Scout  
description: "Specialized in finding SQLi and XSS vulnerabilities.  "
tools: [read, search]  
model: claude-4.7-sonnet  
---  

# Instructions  
You are a Senior Security Engineer.   
1. Always check `/src/auth` first.  
2. Focus on inputs that are not sanitized.  
3. Provide a remediation plan for every bug found.md

1. Description = Routing Key

This is critical.

The system uses the description to decide:

“Should I use this agent?”

Bad:

description: Helps with code

Good:

description: Refactors TypeScript backend services for performance and async safety

Be specific. This directly impacts agent selection and delegation quality.

2. Tools = Capability Boundary

tools: ["read", "search"]

read → open files
search → navigate repo
edit → modify code
execute → run commands

Rule: Default to least privilege.

3. Prompt Body = Behavior Contract

This defines:

Scope (what it can touch)
Process (how it works)
Output format (what it returns)

Treat it like:

“System design for a junior engineer that never sleeps.”

Once you save that file, the agent appears in your menu immediately.

You can also download existing custom agents from Copilot Agent Library https://github.com/proflead/copilot-agent-library

Using Agents in Copilot CLI

copilot --agent security-scout --prompt "Scan auth module"

Or let it infer based on the description.

`/agent` Command

Inside interactive CLI:

/agent

Create or select agents
Manage profiles
Switch context mid-session

Plan vs Autopilot

Plan Mode

The agent proposes steps
You approve before execution

Best for:

Risky changes
Learning/debugging

Autopilot Mode

Agent executes end-to-end
Minimal intervention

Best for:

Repetitive tasks
CI/CD automation

Treat autopilot like: “sudo for AI”

Using Agents in VS Code

In VS Code, agents live inside the Chat Panel and the new Agent Mode.

Agent Mode: Click the “Agent” toggle in the chat. This allows Copilot to perform “Multi-file Edits.”
File Mentions: Use #file or #codebase to give the agent a specific context.
Custom Agents: Use the agent picker (the dropdown at the top of the chat) to select your .agent.md personas.
Tip: If your custom agent isn’t showing up, ensure your settings.json has the absolute path: "chat.agentFilesLocations": ["/Users/vladislav/my-agents"]

Video Tutorial

If you want to see step-by-step examples and a detailed explanation, watch my video tutorial below:

Watch on YouTube: GitHub Copilot Agents

Final Thoughts

Using multiple specialized agents is a skill that will set you apart as a developer. It makes your workflow clearer and much more powerful. If you haven’t tried creating a sub-agent yet, I highly recommend starting today!

Cheers, proflead! ;)

GitHub Copilot CLI: The Complete Developer Guide (2026)

Vladislav Guzey — Thu, 02 Apr 2026 12:01:27 +0000

GitHub Copilot CLI brings Copilot directly into your terminal. You can ask questions, understand a project, write and debug code, review changes, and interact with GitHub without leaving the command line. GitHub says Copilot CLI is available on all Copilot plans. It means you can try it with me today! ;)

What GitHub Copilot CLI is

The easiest way to think about Copilot CLI is this: it is an AI coding assistant designed for terminal-based work. It is not just a chat box. It can inspect your local project, help you edit code, debug problems, summarize changes, and support GitHub workflows from the terminal. GitHub describes it as a terminal-native assistant with agentic capabilities and GitHub workflow integration.

This matters because much real development already happens in the terminal. You run builds, start servers, use git, run tests, inspect logs, and work with Docker there. Copilot CLI embeds AI into that workflow, so you don't have to switch tools. That is the main reason it is useful.

If you want to know a bit more details about it, please watch my video:

Watch on YouTube: GitHub Copilot CLI

How to Install GitHub Copilot CLI

You can install Copilot CLI with npm on all platforms, with Homebrew on macOS and Linux, with WinGet on Windows, or with an install script on macOS and Linux. If you install it with npm, you need Node.js 22 or later.

Install with npm

npm install -g @github/copilot

Install with Homebrew

brew install copilot-cli

Install with WinGet

winget install GitHub.Copilot

This is the official Windows install option in the GitHub docs.

How to Launch Copilot CLI

After installation, start the interactive interface in your project folder (not root folder) in the terminal window with this command:

copilot

When you first launch the CLI, you can use /login and follow the prompts to authenticate with your GitHub account. You usually only need to do this once.

When you start the Copilot CLI in a project folder, GitHub prompts you to confirm that you trust the files in that folder. This is important because during the session, Copilot may try to read, modify, and execute files in that folder and below it. So, only continue if you trust that location.

How Copilot CLI works

You can type prompts in normal English, like:

Explain this project
Find where authentication is handled
Add validation to this form
Help me debug this error

That is the easy part. The more important part is learning the control commands inside the interactive session. These slash commands help you manage the session, switch models, review changes, share results, and use more advanced workflows.

The core slash commands you should know

/help

Use /help to view available commands. This should be your first stop whenever you forget a command or want to see what has changed. GitHub’s docs recommend checking the in-product help because the CLI evolves over time.

/models

Use /models to choose a model. This matters because different models may feel different in speed, reasoning depth, and output style. GitHub also has auto model selection concepts that can reduce the need to choose manually in some cases.

/plan

GitHub’s best practices guide says models do better when given a concrete plan. In Copilot CLI, you can press Shift + Tab to toggle between normal mode and plan mode, or you can use the /plan command from normal mode. In plan mode, Copilot creates a structured implementation plan before any code is written.

This is a very good habit for beginners. Instead of telling Copilot to build something immediately, first ask it to create a plan. That usually makes the next steps cleaner and easier to review. GitHub explicitly recommends planning before coding.

/context

Use /context to inspect how much context is being used. This is especially helpful in longer sessions when you want to avoid running out of room.

/compact

Use /compact to summarize the current conversation and free up space without fully starting over. This is useful when the session gets long but you still want to preserve the important context.

/clear

Use /clear to fully reset the current session. This is the fastest way to start fresh if the conversation has gone off track.

/resume

Use /resume to reopen an earlier session and continue from where you left off. This is one of the best workflow features because you do not always need to restart from zero.

/diff

Use /diff to get a summary of changes made during the session. This is a strong habit before committing, reviewing, or explaining the work to someone else.

/review

Use /review to run the code review agent on the changes. This is one of the most important commands in real use because it helps you check maintainability, bugs, edge cases, and general code quality after generation.

/share

Use /share to export the session to a Markdown file or GitHub gist. This is useful for documentation, debugging, mentoring, and team collaboration.

/session

Use /session to inspect information about the session, such as checkpoints, files, the current plan, or even rename the session. This becomes useful when the workflow gets more complex.

/delegate

Use /delegate when you want to hand the task off to Copilot coding agent on GitHub instead of keeping all work local.

/fleet

The /fleet lets Copilot CLI break down a complex request into smaller tasks and run them in parallel. This is especially useful for bigger maintenance tasks or multi-part work where a single linear flow is slower.

/agent

GitHub also supports custom agents. When using Copilot CLI, you can choose a custom agent with the /agent command, or reference the agent in a prompt or command-line argument.

In simple English, a custom agent is like a specialist teammate. You might create a frontend agent, a documentation agent, a testing agent, or a refactoring agent. This becomes very useful when you want Copilot to behave in a more repeatable and opinionated way for a certain kind of task.

/skills

Skills are reusable capability packages that can add instructions and specialized behavior. You can manage skills with /skills, and the supported subcommands include list, info, add, remove, and reload.

You might create skills for frontend design, documentation generation, PDF handling, release note formatting, or internal coding rules. Skills are especially useful when you do the same kind of work often and do not want to repeat the same long instructions every time.

A simple beginner workflow

If you are new to Copilot CLI, do not start with a giant prompt. Start with a small, safe workflow.

First, move into a project:

cd your-project

copilot

Navigate to a folder with code you want to work with and then enter copilot to start the session.

Then start with project understanding:

Give me a simple overview of this project. Explain the folder structure, main entry points, and what I should read first.

This fits GitHub’s positioning of Copilot CLI as a tool to answer questions and help you understand and work with code from the terminal.

Next, narrow the scope:

Find where authentication is handled and explain it in simple English.

Then plan before editing:

/plan Add basic validation to the login form and keep the current style.

After reviewing the plan, let Copilot implement the small change.

Then inspect the result:

/diff

/review focus on bugs, maintainability, and edge cases

Autopilot mode

A*utopilot or YOLO mode* lets Copilot CLI work autonomously on a task, carrying out multiple steps until the task is complete. In normal use, you usually go back and forth step by step. In autopilot mode, Copilot keeps working after the initial instruction instead of waiting for you after each step.

This is powerful, but it should be used carefully. A practical beginner rule is simple: use normal mode for learning, use plan mode for clearer structure, and move to autopilot only when you understand the task and the repo well.

You can start Copilot in automod by using this command:

copilot --yolo

Or if you launch Copilot, use:

/yolo on

Common mistakes beginners make

The most common mistake is asking for too much at once. Copilot CLI usually works better when the task is small and clear. GitHub’s best-practices guide strongly supports planning first, which is another way of saying: do not jump straight into a giant, vague request.

Another common mistake is accepting generated code without review. That is why /diff and /review should become normal habits. GitHub gives you those commands for a reason.

A third mistake is letting the session become messy. Long sessions are useful, but only if you manage them well with /context, /compact, /clear, and /resume.

A fourth mistake is being too relaxed about permissions. GitHub’s trust warnings are there because Copilot may read, modify, and execute files in the working directory. So take those prompts seriously.

Useful Resources to Learn More about GitHub Copilot

Copilot CLI overview and guides: https://docs.github.com/en/copilot/how-tos/copilot-cli
Getting started: https://docs.github.com/en/copilot/how-tos/copilot-cli/cli-getting-started
Full list of CLI commands: https://docs.github.com/en/copilot/reference/cli-command-reference
GitHub Copilot CLI Free Course (Microsoft): https://developer.microsoft.com/blog/get-started-with-github-copilot-cli-a-free-hands-on-course
Copilot Agent Library: https://github.com/proflead/copilot-agent-library
Scott Hanselman (Microsoft): practical demos, real developer workflows
Dan Wahlin (Microsoft): Great explanations + clean teaching style
Burke Holland: Great content about VS Code and GitHub Copilot

Conclusion

GitHub Copilot CLI is a terminal-native AI assistant that can help you understand projects, plan work, make changes, review code, manage sessions, connect with VS Code, and grow into more advanced workflows with skills, custom agents, and autonomous execution. If you have a Copilot subscription, then definitely give it a shot.

Cheers, proflead! ;)

OpenClaw with Local LLM: Setup Guide Using Ollama

Vladislav Guzey — Thu, 12 Mar 2026 09:56:47 +0000

Vladislav Guzey

Mar 11

How to Set Up OpenClaw & Ollama for a Private AI Assistant

#ai #openclaw #llm

Comments

3 min read

How to Set Up OpenClaw & Ollama for a Private AI Assistant

Vladislav Guzey — Wed, 11 Mar 2026 12:30:19 +0000

Imagine having a personal AI agent running on your computer. It can read files, run commands, automate tasks, and remember your workflows.

In this guide, you will learn how to run OpenClaw with Ollama locally and choose the best local LLM models.

This setup allows you to:

• run AI agents locally

• keep your data private

• avoid cloud API costs

• build powerful automation workflows

By the end of this tutorial, you will have OpenClaw running with a local model using Ollama.

What is OpenClaw?

OpenClaw is an open-source AI agent framework. Unlike a normal chatbot, OpenClaw can perform real actions on your computer.

For example, it can:

• run terminal commands

• read and edit files

• automate workflows

• control browsers

• remember tasks using local memory

OpenClaw acts as a bridge between LLM reasoning models and your operating system.

Why Run OpenClaw with Ollama?

Running OpenClaw with Ollama gives you a fully local AI agent.

Full Privacy. All data stays on your computer.
No API Costs. You don’t need OpenAI or cloud providers.
Faster Performance. Local models remove network latency.
Persistent Memory. OpenClaw stores conversations in local Markdown files, allowing long-term memory.
Messaging Interface. You can control OpenClaw through:

• Telegram

• Slack

• WhatsApp

This allows you to trigger workflows from your phone.

Best Local Models for OpenClaw

Choosing the right local model is important for reliable agent behavior.

For reliable tool usage, use models 14B or larger. Small models often fail when executing multi-step commands.

How to Install OpenClaw with Ollama

Step 1 — Install Ollama

Install Ollama:

curl -fsSL https://ollama.com/install.sh | sh

Verify installation:

curl http://localhost:11434/api/tags

Then download one of these models from ollama.com website:

qwen3-coder — Optimized for coding tasks
glm-4.7 — Strong general-purpose model
gpt-oss:20b — Balanced performance and speed
gpt-oss:120b — Improved capability

Example of command:

ollama run qwen3-coder

Step 2 — Install OpenClaw

Install OpenClaw:

curl -fsSL https://openclaw.ai/install.sh | bash

Run OpenClaw with Ollama by using this command:

ollama launch openclaw

Video Walkthrough

Watch on YouTube: How to Set Up OpenClaw with Ollama

Security: The “Kernel Module” Warning

As of the March 2026 security updates, OpenClaw’s broad permissions are a double-edged sword. Because it operates at the kernel/OS level:

Disable Web Search: For a fully local workflow, toggle search to false In your config, ensure no data snippets are sent to search engines.
Audit Your Logs: OpenClaw saves every action in a local log. Periodically check these to ensure your agent isn’t performing “ghost actions.”
Human in the Loop: Always keep tool permissions set to “ask” for sensitive commands like rm -rf or sending external emails.

Conclusion

If you follow the steps in this guide, you should now have a working OpenClaw setup running with a local model.

Try it out, experiment with different models, and see what kinds of workflows you can automate.

And if you discover something interesting, feel free to share it. I’m always curious to see how people are using these tools.

Cheers, proflead! ;)

I Found an AI Tool That Actually Helps You Remember What You Learn

Vladislav Guzey — Fri, 27 Feb 2026 13:13:11 +0000

Vladislav Guzey

Feb 27

I Found an AI Tool That Actually Helps You Remember What You Learn

#productivity #learning #ai #tooling

Comments 1

6 min read

I Found an AI Tool That Actually Helps You Remember What You Learn

Vladislav Guzey — Fri, 27 Feb 2026 13:05:38 +0000

Think back for a moment, how much do you really remember from what you took in last week?

Maybe you watched some educational videos, saved a few articles, bookmarked tutorials, or highlighted sections of a long report. It felt productive at the time, but recalling those details days later is usually much harder.

Getting information isn’t the hard part anymore; there’s plenty of it everywhere. The real challenge is keeping it in your memory. If we don’t review what we learn, our brains just let it slip away.

Research shows we forget most of what we learn within days unless we actively revisit it. Spaced repetition is a learning technique that resurfaces material at increasing intervals, right before you’re likely to forget it.

Modern apps make it super easy to save content. With one click, it’s stored for “later.” But over time, these saved items pile up into big personal libraries that most of us rarely revisit.

Saving things can feel productive, but it’s not the same as actually learning.

This gap between taking in information and actually remembering it is what got me interested in Recall. It’s an AI-powered knowledge base designed not just to organize what you find, but to help you remember it.

Watch on YouTube: This AI Uses Spaced Repetition to Help You Remember More

From Saving Content to Building Knowledge

If you work in a field where learning is constant, you know the routine. Developers keep up with new tech, students juggle big reading lists, and professionals try to stay up to date in fast-changing industries.

It’s natural to save anything that seems useful, a technical article, a conference talk, or a research paper you want to check out later. Over time, these add up to a personal archive. But building a library isn’t the same as building real knowledge. Even if we read or watch something closely, if we don’t review it, most of the details fade in just a few days. What’s left is usually just a vague sense of familiarity, not something you can use with confidence.

Some people try to solve this with note-taking systems or flashcards. These can work, but they usually take a lot of manual effort, organizing notes, making cards, and connecting ideas.

Recall takes a different approach. Instead of making you build a learning system yourself, it automates much of the process and helps you go back to what you’ve saved.

What Recall Does

Recall is more of an AI-powered knowledge base than a regular note-taking app. You can save content from lots of sources, YouTube videos, articles, PDFs, podcasts, and your own notes. After you save something, the platform creates summaries and organizes them for you.

Over time, Recall links related topics together, creating a structured network rather than just separate notes. You can even chat with your knowledge base to bring up ideas from the content you’ve collected.

While other AI tools are adding similar features, Recall focuses more on helping you remember what you’ve saved. That’s where Quiz 2.0 comes in.

A Closer Look at Quiz 2.0

Recall already had a quiz feature, but the new version adds more options. Now, Quiz 2.0 lets you use open-ended questions and flashcards, so you practice recalling information from memory instead of just picking the right answer.

The goal is to help you use active recall, a learning method that improves memory by making your brain work harder. Studies show that this effort is important for building long-term memory.

One helpful feature is that you can quiz yourself on almost anything. You are not limited to online videos or articles. You can also create quizzes from your own notes, which is great for studying lectures or personal research. If you prefer to stay organized, you can write notes in Recall and turn them into quizzes whenever you want to review.

The system uses spaced repetition in the background. This means material comes back at longer intervals, usually just before you might forget it. If you get a question right, you will see it less often. If you have trouble, it comes back sooner. This way, you can focus on what you need to practice most without repeating what you already know.

You can customize your quiz setup in many ways. Choose the topics, set the difficulty, pick how many questions you want, and use a timer for focused sessions. This makes each review fit your schedule and learning goals, so the experience feels flexible instead of fixed.

Using Recall in Practice

To really test the platform, I saved content I actually wanted to remember, mostly technical videos and long articles. The browser extension made it quick to capture items, and after saving, Recall automatically generated a summary and added tags.

After I had a few items saved, I tried out Quiz 2.0. That’s when it changed from just storing things to actually interacting with them.

Some questions were direct, while others forced me to hesitate and think. Open-ended questions, in particular, required me to retrieve ideas without prompts — something that is noticeably harder than identifying the correct answer. That effort is important because learning tends to deepen when the brain has to work for the information.

There are features to help you stay consistent, too. A streak tracker motivates you to review regularly, and optional timers can cut down on distractions during short study sessions. You can also share quizzes to challenge a friend or coworker. For students or teams, this social side could make things more motivating.

Does It Actually Help You Remember?

No tool can promise perfect memory, and Recall doesn’t claim to. What it does offer is structure, and that often makes the difference in whether you remember things. The quizzes acted as gentle reminders, turning saved content into something you use again.

Without those reminders, many knowledge tools just end up as archives rather than real learning spaces. Quiz 2.0 makes it easier to review what you’ve saved, and that lower effort could help you stick with learning over time.

This approach reflects a broader shift toward using AI to support active learning instead of passive consumption. Rather than just collecting information, you interact with it, test your understanding, and revisit key ideas when needed.

Where It Fits

There are lots of knowledge tools out there, each with its own approach. Some let you customize everything, while others focus on manual notes or flashcards.

Recall is all about automation, summaries, organizing, connecting ideas, and making quizzes, all with very little setup. If you like moving quickly from saving to reviewing, this style might feel right for you.

Instead of replacing all your other tools, it’s better to see getrecall.ai as something that can fit alongside what you already use.

Conclusion

The toughest part of learning today isn’t finding information; it’s holding onto it. Getrecall.ai tries to solve this by mixing knowledge storage with regular review, and Quiz 2.0 is a big part of that. Supporting active recall and smart review timing, it helps turn what you save into lasting knowledge.

It’s not a magic fix, and you still have to be consistent. But tools that make it easier to review what you’ve learned can help you remember more over time. If you often feel like you forget most of what you take in, this might be worth a try.

You can find out more at Recall. There’s a free version to try, and a premium plan with extra features. If you want to upgrade, use the promo code prof25 for 25% off a subscription until April 1, 2026.

Choosing the Best AI Coding Assistant: GPT-5.3 Codex or Claude Opus 4.6

Vladislav Guzey — Mon, 16 Feb 2026 12:52:34 +0000

Vladislav Guzey

Feb 16

GPT-5.3 Codex vs Claude Opus 4.6: Real Developer Tests and Results

#ai #programming #tooling #nocode

Comments 1

4 min read

GPT-5.3 Codex vs Claude Opus 4.6: Real Developer Tests and Results

Vladislav Guzey — Mon, 16 Feb 2026 12:52:08 +0000

If you are a new developer, you have probably hit the “subscription wall.” You have $20 a month to spend on an AI coding assistant, but you don’t know which one to pick.

Codex GPT-5.3 vs Claude Opus 4.6: Which $20 Subscription Should You Buy in 2026?

Just a few years ago, developers were debating whether AI could help them write code. Today, that question is gone. AI is already part of the workflow.

Now the real question is: Which AI coding assistant should you use?

Two tools are currently dominating conversations among developers: GPT-5.3 Codex and Claude Opus 4.6. Both promise faster development, smarter debugging, and the ability to build real applications in minutes. Both are available on roughly similar entry-level plans.

But if you are a new developer, choosing the wrong tool can slow your progress. The right one, on the other hand, can dramatically accelerate your learning.

To understand the real differences, I tested both models across multiple developer tasks, from building apps to debugging code to creating a playable game.

If you want to know what actually happened. Please read this article or watch my YouTube video:

Watch on YouTube: Claude Opus 4.6 or Codex CLI GPT-5.3

Testing Approach

For this comparison, I intentionally avoided complex prompts.

Why? Because beginner developers rarely write perfect instructions. Most people simply describe what they want and expect the AI to figure it out.

So I used simple, realistic prompts and ran both tools side by side:

Claude Opus 4.6 inside Claude Code
GPT-5.3 through Codex CLI

The goal was not to chase benchmarks. It was to observe how these models behave in real development scenarios.

Building a Full-Stack Application

The first test was straightforward: create a full-stack to-do application.

At first, Codex looked faster. It immediately started generating code, while Claude paused to produce a structured plan.

This difference is more important than it might seem.

Claude’s plan acts like a blueprint. If something is wrong, you can fix the direction early — before hundreds of lines of code are written. For beginners, especially, this reduces confusion later.

Surprisingly, Claude finished the entire app in about four minutes. Codex followed roughly two minutes later.

Codex delivered a more polished interface and even included basic form validation. Claude’s version looked simpler and skipped validation, but its internal structure felt more deliberate.

What I’ve noticed is that Codex is often optimized for results, whereas Claude is optimized for the process.

Neither approach is inherently better; it depends on what you value.

The Hidden Reality: Usage Limits

Pricing between these tools appears similar at first glance, but the real difference shows up in daily usage limits.

Eventually, both platforms may push you toward API usage, which adds extra cost. However, Codex typically allows larger daily workloads before hitting restrictions.

For beginners who are experimenting, breaking things, and trying again, this matters more than most people realize.

Running into a limit in the middle of a project is not just annoying; it interrupts learning.

Debugging a Broken Application

Next, I deliberately removed the backend from the app and asked both models to diagnose the problem.

Claude identified the issue in about thirty seconds and fixed it using minimal context.

Codex also solved it correctly, but took roughly twice as long and used significantly more tokens.

The difference highlights something fundamental: Debugging is not about speed; it is about reasoning. Claude clearly demonstrated strength in that area.

Analyzing Architecture

When asked to review the codebase and suggest improvements, both models performed well.

However, Claude produced more detailed feedback. Its suggestions were clearer, better formatted, and easier to follow.

Codex was not far behind; it simply felt less granular.

For an experienced engineer, that gap might not matter. For a beginner, clarity can make a huge difference.

More examples you can see in my video:

Watch on YouTube: Claude Opus 4.6 or Codex CLI GPT-5.3

The Most Important Insight

After all the tests, one pattern became impossible to ignore.

Codex behaves like an executor. It moves quickly, writes code immediately, and focuses on momentum.

Claude behaves like an architect. It plans, clarifies requirements, and carefully structures solutions.

This is not a matter of one being superior. They are built for different ways of working.

So Which One Should You Choose?

If you already subscribe to ChatGPT Plus, sticking with Codex makes sense. It is fast, capable, and its larger limits support frequent experimentation.

If you are already using Claude Pro, there is little reason to switch. Claude excels at planning, architecture, and producing structured code.

However, be aware that heavier usage may require higher-tier plans.

For developers starting from zero, the decision becomes more nuanced.

Codex is often the easier entry point simply because you can use it more without hitting limits. More usage means more practice, and practice is what builds skill.

Later, as your projects grow more complex, Claude becomes incredibly valuable for deeper engineering tasks.

In simple terms:

Codex helps you move faster.
Claude helps you think better.

The strongest developers will likely use both.

Use them wisely, keep learning, and focus on fundamentals.

Let me know which one you choose in the comments below!

Cheers, proflead! ;)

No‑Code with AI: Softr’s Vibe Coding Turns Data Into Real Apps

Vladislav Guzey — Tue, 10 Feb 2026 11:22:59 +0000

Vladislav Guzey

Feb 10

Build Real Apps with Softr: AI‑Powered No‑Code Platform for 2026

#ai #nocode #tooling #webdev

Comments 1

7 min read

DEV Community: Vladislav Guzey

Build Your First AI Agent with Google CLI (Step-by-Step)

What is Google Agents CLI? Full Beginner Guide

What is Google Agents CLI? Full Beginner Guide

What is the Google Agents CLI?

Skills packaged for agents

How to Install Google Agents CLI?

Prerequisites

Installation Steps

Authentication

Building Your First “Weather” Agent

Install Dependencies

The Playground

Deploy AI Agents

The Deployment Process

Agents CLI Key Commands Cheat Sheet

Building an agent with your coding assistant

Video Tutorial: Agents CLI Explained

Conclusion

GitHub Copilot AI Agents: The Complete Technical Deep Dive

GitHub Copilot AI Agents: The Secret to 10x Engineering in 2026

GitHub Copilot AI Agents: The Secret to 10x Engineering in 2026

Getting Started: The Setup

What are GitHub Copilot Agents?

The 3 Types of Copilot Agents

1. Local Agents

2. Background Agents (Copilot CLI)

3. Cloud Agents

Building Your Own Custom Agent

Where to put the file:

2. Tools = Capability Boundary

3. Prompt Body = Behavior Contract

Using Agents in Copilot CLI

/agent Command

Plan vs Autopilot

Plan Mode

Autopilot Mode

Using Agents in VS Code

Video Tutorial

Final Thoughts

GitHub Copilot CLI: The Complete Developer Guide (2026)

What GitHub Copilot CLI is

How to Install GitHub Copilot CLI

How to Launch Copilot CLI

How Copilot CLI works

The core slash commands you should know

A simple beginner workflow

Autopilot mode

Common mistakes beginners make

Useful Resources to Learn More about GitHub Copilot

Conclusion

OpenClaw with Local LLM: Setup Guide Using Ollama

How to Set Up OpenClaw & Ollama for a Private AI Assistant

How to Set Up OpenClaw & Ollama for a Private AI Assistant

What is OpenClaw?

Why Run OpenClaw with Ollama?

Best Local Models for OpenClaw

How to Install OpenClaw with Ollama

Step 1 — Install Ollama

Step 2 — Install OpenClaw

Video Walkthrough

Security: The “Kernel Module” Warning

Conclusion

I Found an AI Tool That Actually Helps You Remember What You Learn

I Found an AI Tool That Actually Helps You Remember What You Learn

I Found an AI Tool That Actually Helps You Remember What You Learn

From Saving Content to Building Knowledge

What Recall Does

A Closer Look at Quiz 2.0

Using Recall in Practice

Does It Actually Help You Remember?

Where It Fits

Conclusion

Choosing the Best AI Coding Assistant: GPT-5.3 Codex or Claude Opus 4.6

GPT-5.3 Codex vs Claude Opus 4.6: Real Developer Tests and Results

GPT-5.3 Codex vs Claude Opus 4.6: Real Developer Tests and Results

Testing Approach

Building a Full-Stack Application

The Hidden Reality: Usage Limits

Debugging a Broken Application

`/agent` Command