The new /goal command in OpenAI Codex changes this workflow.

Instead of asking for isolated answers, you can give Codex a long-term objective with clear success conditions. Codex can investigate, write code, run tests, and continue working toward the result over multiple steps.

In this guide, you’ll learn:

• What /goal does
• How it works
• How to enable it
• Real examples
• Best practices
• Common mistakes

What Is the /goal Command in Codex?

The /goal command lets you define a persistent objective for Codex.

Instead of treating every message as a separate request, Codex keeps working toward the same result until:

• The goal is completed
• You pause it
• You clear it
• It gets blocked
• Resource limits are reached

Think of it like giving an AI developer a task and letting it continue working without repeating instructions.

How the Goal Lifecycle Works

Goals usually follow a simple workflow.

Step 1: Define the objective

You tell Codex what should happen.

Example:

/goal Reduce dashboard page load time below 2 seconds

Step 2: Codex investigates and plans

Codex may:

• Read files
• Analyze code
• Check dependencies
• Search for issues
• Plan next actions

Step 3: Execute and verify

Codex can:

• Write code
• Run tests
• Refactor functions
• Validate changes

Step 4: Complete or pause

Once conditions are met, the goal can be finished.

You can also pause and resume work later.

When to Use /goal

Goals work best for tasks that require multiple steps.

Good use cases:

Performance optimization

/goal Reduce homepage loading time

Constraints:
- Keep existing UI
- Keep Lighthouse score above 90
- Target loading under 2 seconds

Finding difficult bugs

/goal Investigate memory leaks in analytics.ts

Constraints:
- Keep existing architecture
- Add tests if needed
- Clearly label uncertain findings

Writing test coverage

/goal Create unit tests for auth.ts

Constraints:
- Reach at least 90% coverage
- Do not modify business logic

Large refactoring work

/goal Refactor payment module

Constraints:
- Preserve API behavior
- Keep tests passing
- Improve readability

When NOT to Use /goal

Goals are not the right tool for every task.

Avoid using /goal for:

• One-line edits
• Quick explanations
• Small bug fixes
• Short code reviews
• Questions with one answer

Bad example:

/goal Make this code better

Why this is bad:

“Better” has no clear finish line.

Codex may continue making changes without knowing when to stop.

Better version:

/goal Refactor user-service.ts

Constraints:
- Keep API unchanged
- Improve readability
- Keep tests passing

How to Enable /goal in Codex

Update Codex:

npm install -g @openai/codex@latest

Verify installation:

codex --version

Some Codex versions may require enabling goal-related features. In order to do that find the config.toml file and add this line:

[features]
goals = true

Goal Commands

Create a goal:

/goal Finish dashboard migration

Check current goal:

/goal

Pause:

/goal pause

Resume:

/goal resume

Clear:

/goal clear

Good vs Bad Goal Prompts

Bad

/goal Refactor this code and make it better

Problems:

• No measurable result
• No constraints
• No finish line

Good

/goal Optimize database queries in db.ts

Constraints:
- Keep schema unchanged
- Cover all execution paths with tests
- Target execution time below 50ms

Why it works:

• Clear objective
• Defined limits
• Measurable result

Permission and Safety Tips

Codex may ask for confirmation before actions that can change files or execute commands.

Before running long autonomous tasks:

Keep Git clean

Create a new branch:

git checkout -b codex-experiment

Commit before running goals

git add .
git commit -m "Clean starting point"

Avoid sensitive environments

Do not run autonomous tasks:

• On production systems
• With exposed secrets
• On important system folders

Best Practices

Define a clear finish line

Bad:

/goal Improve performance

Better:

/goal Reduce API response time below 150ms

Define constraints

Tell Codex what should not change.

Examples:

• Keep API unchanged
• Keep tests passing
• Do not change database schema

Do not hide uncertainty

If data may be unavailable:

If metrics cannot be collected, label results as estimated.

Use measurable targets

Examples:

• Response time under 100ms
• 95% test coverage
• Lighthouse score above 90

Video Tutorial

Watch on YouTube: Codex /goal explained

Conclusion

The /goal command changes Codex from a prompt-response tool into a longer-running coding workflow.

Instead of repeating instructions every few minutes, you give Codex a clear objective, define constraints, and let evidence decide when work is complete.

Give it a shot and share your feedback in the comments under my YouTube video! ;)

Cheers, proflead! ;)

Google recently released the Agents 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-agentba

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:

1. Cloud Run: This treats your agent like a standard web application. It’s great if you want total control over the server.
2. 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

1. Ensure you have a Google Cloud Project set up.
2. Enable billing in the Cloud Console.
3. 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 simple 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! ;)

Google Agents CLI Explained in 5 Minutes was originally published in Google Cloud - Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

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.

1. Update VS Code: Ensure you are on the latest version.
2. 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.”

1. You can either write it from scratch or let Copilot generate a template for you.
2. 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 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

Autopilot 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! ;)

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.

1. Full Privacy. All data stays on your computer.

2. No API Costs. You don’t need OpenAI or cloud providers.

3. Faster Performance. Local models remove network latency.

4. Persistent Memory. OpenClaw stores conversations in local Markdown files, allowing long-term memory.

5. 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! ;)

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.

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! ;)

AI app builders have become very good at generating interfaces. From a technical perspective, that part is mostly solved. The harder problem is what comes next: connecting real data, enforcing user permissions, handling workflows, and deploying the app after the generation.

I was recently introduced to Softr, an AI no-code platform for building full-stack web apps. You can start from scratch using Softr’s database or build on existing data. At first, I thought it was another AI web app builder, but I was wrong. So give me about 5–10 minutes, and I will show you what you can do with it.

What Softr Is

Softr is a full-stack no-code app builder for turning real data into real applications. It’s built for teams and builders who want to create internal tools, dashboards, and operational apps without writing code, while keeping structure, security, and control.

Unlike many tools that focus only on the front end, Softr natively provides the three core components of an app: the interface, the database, and workflows.

The interface is where users log in and interact, the database stores structured data, and workflows make the app dynamic by triggering automations and integrations.

What You Can Build with Softr

For example, you can build an internal sales dashboard connected to a spreadsheet, a client portal where each customer sees only their own data, an operations tool for managing records and statuses, or a reporting app that updates automatically as data changes.

You can start from scratch using Softr Databases as your backend, or you can migrate or use existing data from other tools. Softr supports more than 17 data sources, including:

• Google Sheets
• Notion
• HubSpot
• Supabase
• SQL
• Airtable
• Softr’s own database
• And more

Once the data is connected, you build pages that display, filter, and update that data. Users can log in, see different views based on their role, and interact with the app in a controlled way. All of this you can do without writing a single line of code!

Workflows and Integrations

Beyond data and UI, Softr includes native workflows that are deeply integrated into the apps you build. These workflows let your app respond to events and interact directly with your app’s data.

For example, a workflow can:

• Update app data (e.g. when all tasks are marked Done, automatically mark the project as Done in the database)
• Connect to other tools (e.g. send reminder emails before a task’s due date, notify your team on Slack)
• Use AI (e.g. generate an AI summary from a record and send it by email)

Workflows can be triggered by user actions such as button clicks or form submissions. While the workflow runs, the user can see a loading state, then be redirected to another page or shown a personalized message. This tight integration is a key advantage compared to using external automation tools alone.

Softr also integrates with third-party automation platforms such as Zapier, Make, and n8n, enabling your app to connect to larger systems rather than operate in isolation.

AI in Softr

On top of this foundation, Softr adds several AI-powered features, including the Vibe Coding block, Database AI Agents, Ask AI, and other AI-assisted capabilities.

Each of these serves a different purpose, but the most interesting for building custom apps is AI for the builder, including the Vibe Coding block and AI-assisted database and workflow creation. This is where the rest of this article will focus.

Vibe Coding Block

Most no-code platforms rely on predefined components. These components are useful and fast, and for most business apps, they should not be reinvented. Tables, kanban boards, forms, and simple charts are common patterns that users already understand.

But this approach also creates a ceiling. When you reach the small set of blocks that need deeper customization, predefined components are no longer enough. The Vibe Coding block is Softr’s answer to that limitation.

It lets you describe custom UI and application logic in natural language and generate it directly inside a Softr app. Instead of working around existing blocks, you can define new behavior where it’s needed.

Vibe Coding blocks are fully dynamic. They natively and safely connect to real data sources, such as Softr Databases, Airtable, or Google Sheets, and respond to filters, user input, and state changes in real time. They support conditional logic and visibility rules, so interfaces behave differently based on the user, role, or context.

You can also use Vibe Coding to generate custom forms, internal tools, or interactive components that don’t exist as default blocks. This is where the platform starts to feel less like a template-based builder and more like a flexible application framework.​

Because the Vibe Coding block lives within Softr’s system, it uses the same data model, permission rules, theme, and workflows as the rest of the app. Any logic you generate respects access controls, follows the app’s visual theme, and can trigger the same automations and integrations, making it suitable for real, production use.

How to Use the Vibe Coding Block

Let’s look at a few concrete examples to see how the Vibe Coding block behaves inside a real Softr app.​

You can find the “Vibe coding” block in the “Browse blocks” section.

Click the yellow plus button in order to add the block to the canvas.

Then select your data source from the “Source” tab

Use case: Interactive Quiz

My first example is an interactive quiz. Here is the prompt:

Based on the database listing questions, generate an interactive quiz block allowing to pick an answer from the list of answers, reveal a hint to get help, and goes through the questions one by one before showing a final result screen with the score, also allowing to review all answers

And this is the result:

Use Case 2: Mini CRM

In my second example, I showed a mini CRM. We built a “Deal pipeline”. The prompt:

Create a lightweight CRM interface. Allow adding contact. Display deal stages in a Kanban view. Enable drag-and-drop to update stages. Show deal value totals per column.

In about 2 minutes, I got my mini CRM.

Use Case 3: Sales Dashboard

In my final example, I created a sales dashboard using data from my Google Sheet. This is the prompt:

Generate an executive sales dashboard using the sales database.

At the top, create KPI cards showing:
- Total Revenue
- Deals Closed This Month
- Average Deal Size
- Win Rate

Add visual indicators showing growth or decline compared to last month.

Below the KPI cards, create:

1. A revenue trend line chart by month.
2. A bar chart showing revenue by sales rep.
3. A funnel visualization for pipeline stages.
4. A table listing high-value deals over $25,000.

Highlight negative trends in red and positive trends in green.

Make the layout clean, modern, and optimized for quick executive review.

The result:

And all of these without writing a single line of code!

Video Example of Vibe Coding Block in Action

In the video below, I’ll walk you through the process step by step. You will see how I’m using the Vibe coding blocks, and by the end, we’ll publish the app so it’s ready for real end users.

Watch on YouTube: Softr Tutorial — Build A Real APP, Not a Prototype

Deploying the App

Once the app is ready, deployment is straightforward. You just click a couple of buttons in the interface, and that’s it. You’re not exporting code or moving to another environment. The app you build is the app that gets published.

You can choose whether the app is internal, restricted to logged-in users, or publicly accessible. For internal tools, access is usually limited to specific roles. For public apps, you can still control which parts require authentication.

Deployment here means making the app available to real users, not sharing a prototype link.

Softr Pricing

You can start with Softr for free or choose a package below.

Conclusion

If you already have data and want to build a real app on top of it without writing code, Softr is worth exploring. Most business apps don’t need to be reinvented, and asking AI to generate everything end-to-end only increases the risk of errors and debugging.

By using AI where it makes sense, like vibe-coding custom blocks on top of a reliable, modern no-code infrastructure, you get the flexibility of AI with the stability needed to ship robust, production-ready business apps.

Give it a shot and share your feedback in the comments below.

Cheers, proflead! ;)

How to Set Up OpenClaw

Install OpenClaw

First, open your terminal (Command Prompt or Terminal on Mac/Linux). You need to install the tool globally. Run this command:

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

OR if using npm directly:

npm install -g openclaw

Run the Onboarding Wizard

Once installed, start the configuration process:

openclaw onboard

• Security Warning: You will see a warning that the bot works on your local machine. Read it and accept.
• Quick Start: Select “Quick Start” for the easiest setup.

Model Selection: Choose your AI provider (e.g., OpenAI Codex or GPT-4). You will need to log in to your provider account.

Connect a chat platform — After the model is selected, OpenClaw asks you to set up a chat interface. Select your preferred platform (e.g., Telegram).

1. Open Telegram and search for @BotFather.
2. Send the command /newbot.
3. Give your bot a name and a username (must end in _bot).
4. Copy the Token provided by BotFather.
5. Paste this token into your terminal when OpenClaw asks for it.

A similar process applies to WhatsApp, Discord, and other chat platforms.

Get Your User ID

You need to tell OpenClaw who is allowed to talk to it.

1. Search for @userinfobot in Telegram.
2. Click “Start” to see your ID (a number).
3. Copy and paste this ID into the OpenClaw terminal.

Pair Your Bot

Restart your gateway to apply changes:

openclaw gateway restart

Configure skills (optional) — OpenClaw can install skills (tools) to perform tasks such as sending emails or editing files. During onboarding, you can skip or install skills. If you choose to install, use npm as the node manager; otherwise, select Skip for now.

Provide API keys (optional) — Some skills require API keys (e.g., Brave Search API). During setup, you can say No if you don’t have keys yet.

Choose UI — OpenClaw offers a web‑based Control UI or a TUI. The TUI keeps everything in the command line and is recommended for first‑time setup. When ready, select Hatch in TUI to start the bot’s personality configuration. The bot will ask for its name and how to address you. After that, OpenClaw is ready to chat via the terminal and your chosen chat platform

If you get stuck, please watch my YouTube tutorial:

Watch on YouTube: How to Set Up OpenClaw

Extending capabilities

OpenClaw can perform additional tasks after the initial setup.

• Web searches — If you ask the bot how to perform web searches, it will guide you through obtaining an API key (for example, from the Brave Web Search API) and sending it to the bot via chat. Once the key is set, OpenClaw can search the web and return results.
• File operations — You can instruct your bot to research a topic and save the results to a Markdown file. The bot will generate the file and include citations.

Remember that each new capability increases the bot’s permissions, so enable them carefully and keep security in mind.

How to Secure OpenClaw

By default, giving an AI access to your computer carries risks. Follow these steps to lock it down.

Restrict Gateway Access

Your bot shouldn’t be visible to the whole internet.

• Open your config file: ~/.openclaw/openclaw.json
• Find the gateway section.
• Change the address 0.0.0.0 to 127.0.0.1 (loopback) This ensures only you (localhost) can access the gateway.

Enable Authentication

Make sure your gateway requires a token:

• In the same config file, ensure authentication is set to mode: "token".
• Verify a token is present. Treat this token like a password.

Set Channel Policies

Don’t let your bot talk to strangers.

• DM Policy: Set to "pairing" (requires approval).
• Group Policy: Set to "disabled" so the bot can't be added to public groups where it might leak data.

...
  "channels": {
    "telegram": {
      "dmPolicy": "pairing",
      "groupPolicy": "mention"
    }
  }
...

Secure Your Credentials

Protect the files that store your API keys. Run this command to make sure only your user can read the credentials file:

chmod 700 ~/.openclaw/credentials

Run a Security Audit

OpenClaw has a built-in tool to check for holes. Run this regularly:

openclaw security audit --deep --fix

If it finds issues, you can often fix them automatically with:

openclaw doctor --fix

Watch Out for “Prompt Injection”

Be careful when asking your bot to browse the web or read untrusted files. Bad actors can hide commands in text that trick the AI. Always use the Sandbox environment when experimenting with untrusted data.

Final Step

After applying these security fixes, always restart your gateway:

openclaw gateway restart

If you want a simple walkthrough, please check my video tutorial:

Watch on YouTube: How to secure OpenClaw Bot

Conclusion

OpenClaw gives you the power of a personal AI assistant that runs on your own hardware. When configured correctly, it can search the web, manage files, and respond to your chat messages across multiple platforms. However, because it uses tools that can execute commands on your system, security must be a first‑class concern.

Stay safe! Cheers! :)

Installing Ollama

Ollama is a locally deployed AI model runner that lets you download and run large language models on your own machine. It provides a command-line interface and an API, supports open models such as Mistral and Gemma, and uses quantization to make models run efficiently on consumer hardware. A model file allows you to customise base models, system prompts, and parameters (temperature, top-p, top-k). Running models locally gives you offline capability and protects sensitive data.

To use Claude Code with local models, you need Ollama v0.14.0 or later. The January 2026 blog notes that this version implements Anthropic Messages API compatibility. For streaming tool calls (used when Claude Code executes functions or scripts), a pre-release such as 0.14.3‑rc1 may be required.

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

After installation, verify the version with ollama version.

Pulling a model

Choose a local model suitable for coding tasks. You can see the full list on https://ollama.com/search website. Pulling a model downloads and configures it. For example:

# Pull the 20 B parameter GPT‑OSS model
ollama pull gpt-oss:20b

# Pull Qwen Coder (a general coding model)
ollama pull qwen3-coder

To use Claude Code’s advanced tool features locally, the article Running Claude Code fully local recommends GLM-4.7-flash because it supports tool-calling and provides a 128K context length. Pull it with:

ollama pull glm-4.7-flash:latest

Installing Claude Code

Claude Code is Anthropic’s agentic coding tool. It can read and modify files, run tests, fix bugs, and even handle merge conflicts across your entire code base. It uses large language models to act as a pair of autonomous hands in your terminal, letting you vibe-code (describing what you want in plain language and letting the AI generate the code).

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

From your terminal, run:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434

# Launch the integration interactively
ollama launch claude

Then you will see the model list that you installed in the previous step. Select the one you want to test, then hit Enter.

And that’s it! Now your Claude code works with Ollama and local models.

Video Tutorial

Watch on YouTube: Claude Code with Ollama

Summary

By pairing Claude Code with Ollama, you can run agentic coding workflows entirely on your own machine. Don’t expect the same experience as with the Anthropic models!

Experiment with different models and share with me which one worked the best for you!

Cheers! ;)