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

Modern software development rarely happens in one place. You might start a coding session at the office, but later need to finish the job from a different computer.

There is a way. You have to push code to GitHub, pull it down on your other machine, and-worst of all-you lose your entire conversation history with your AI assistant.

Recently, I started using Session Teleportation in Claude Code. It allows you to move an entire conversation, including context, history, and the working branch, between the web and your local terminal.

In this tutorial, I show you how it works and how to use it to make your workflow seamless.

First-Time Setup (Do This First)

Before you can teleport anything, you need to connect your local environment to Claude’s cloud.

Install and Update First, make sure you have the latest version of Claude Code.

npm install -g @anthropic-ai/claude-code

or use this comand:

claude update

Turn on Claude Code on Web

Open the website https://claude.ai/code and finish the onboarding.

You must connect your GitHub account. This is critical because Claude needs access to your repositories to “teleport” the code changes between devices.

Note: If you use an organization’s repository (like at work), you might need to click “Grant” next to your organization’s name in the GitHub permissions screen.

Then set up cloud environments. Give it a name and network access.

How Session Teleportation Works

Navigate to your project folder in the terminal and run claude. Claude will detect your git repository and make sure it has permission to access it.

The teleportation is built around two simple commands.

1. The & Prefix (Send to Web) This is how you start a "background session." If I type & before my prompt in the CLI or VS Code, Claude runs the task on its cloud infrastructure.

• Example: & Refactor the authentication module to use JWT tokens

2. The /teleport Command (Bring to Local): This is how you resume work. You can pull that web session into your local terminal or VS Code using claude --teleport <session-id>.

Important Note: This process is one-way. You can pull a web session down to your terminal, but you cannot “push” an existing local session up to the web. If you think you might need to switch devices later, always start your task with the & prefix!

Moving Tasks from VS Code to the Web

Install the Claude Code extension in VS Code or Cursor (via the Extensions panel). Once installed, you can send tasks to the web directly from within your editor.

Compose your prompt. For example, if you want Claude to refactor authentication logic, start your prompt with &:

& Refactor the authentication module to use JWT tokens instead of sessions

This creates a background web session and returns a session ID. The task continues even if you close VS Code or shut down your laptop.

Monitor the session. Use /tasks in the CLI or click on the task in the web interface to see status.

You can also run claude — status <session‑id> from any device.

Pulling Web Sessions Back to Your Terminal (VS Code or Cursor)

Locate your session. In the Claude chat, run /teleport (or /tp) to see all active web sessions. From the command line, run claude — teleport for an interactive picker or claude — teleport <session‑id> to resume a specific session.

claude --teleport session_01RyZ89nysBFFZnqFMZ4KpkZ

Meet the requirements. Before teleporting, Claude checks several conditions:

• Clean Git state: You must have no uncommitted changes. Teleport will prompt you to stash them if necessary.
• Correct repository: You must be in a checkout of the same repository used on the web.
• Branch availability: The branch created during the web session must be pushed to the remote; teleport will fetch and check it out.
• Same account: You must be authenticated as the same Claude.ai user.

Teleport the session. Once these conditions are satisfied, Claude will fetch the branch, load the conversation history, and attach the session to your local environment. You can then continue the conversation and review code in Cursor or the terminal as if you never left.

Pro Tips for Getting the Most Out of Claude Code Teleport

• Parallel Work Streams: Sometimes I run multiple & commands at once to start several tasks simultaneously.
• Team Collaboration: This is a hidden gem. I can share a Session ID with a teammate, and they can teleport into my session on their machine. It is perfect for async pair programming.
• One-Way Only: Remember, you can pull a web session down to your terminal, but you cannot “push” an existing local session up to the web. Always start with & if you think you might need to move!
• Maintain a clean Git state. Teleportation requires a clean working directory. Use Git stashes or commit your changes before pulling sessions

Claude Code Teleportation Tutorial

I also have a video with step-by-step instructions on how to use Claude Code teleportation. Please make sure to check it out.

Watch on YouTube: Claude Code Tutorial: Teleportation

Conclusion

Session teleportation blurs the line between local and remote development. It allows you to offload compute‑heavy tasks to the cloud, then seamlessly resume work locally without losing context. This cross‑device mobility is valuable for distributed teams and individuals who switch machines throughout the day.

I hope you found this tutorial helpful. If so, please leave your comments and subscribe to my YouTube channel, where I share a lot of useful tutorials for devs ;).

Cheers!

What Are Codex Skills?

A Codex Skill is a reusable workflow packaged into a folder. Instead of rewriting the same instructions every time, you write them once inside the skill and let Codex handle the work.

Skills help you extend Codex with specific expertise and save time.

How Skills Work — Progressive Disclosure

Skills use a method called Progressive Disclosure:

• Startup: Codex loads only the names and descriptions of all skills.
• On Demand: When you request a skill, Codex loads the full SKILL.md file.
• Efficient: Tokens are used only when needed.

This keeps performance fast and context clean.

Where Skills Live (Skill Scopes)

Skills can be stored in different places:

• Global Level: Across all projects
• User Level: Available to your user
• Repository Level: Inside a specific project
• System Level: Default built-in skills

How to Install Existing Skills

Before using or creating skills, make sure your Codex CLI is updated to the latest version. The Skill Creator and Skill Installer options depend on the latest CLI features. If your version is outdated, these options may not appear in the terminal.

To install an existing skill:

• Open Codex in the terminal
• Type $
• Choose Skill Installer
• Enter a skill name or paste a GitHub URL
• Codex installs it
• Restart Codex

After a restart, type $ again, and you will see your installed skills.

How to Create Custom Skills

There are two ways:

Method A: Using the CLI Creator

• Start Codex and type $
• Choose Skill Creator
• Enter the name
• Enter the instruction
• Codex asks follow-up questions and builds the skill

If the skill ends up outside the .codex/skills folder, you must install it manually.

Simply follow the instructions above, “How to Install Existing Skills”.

Method B: Manual Creation (Recommended)

A skill has a simple folder structure:

• skill.md (Required): Main instruction file
• scripts/ (Optional): Code scripts for logic
• references/ (Optional): Docs or templates
• assets/ (Optional): Extra resources

The template of SKILL.md file:

---
name: skill-name
description: Description that helps Codex select the skill
metadata:
  short-description: Optional user-facing description
---

Skill instructions for the Codex agent to follow when using this skill.

The example of SKILL.md file:

---
name: prompt-optimization
description: Improve and rewrite user prompts to reduce ambiguity and improve LLM output quality. Use when a user asks to optimize, refine, clarify, or rewrite a prompt for better results, or when the request is about prompt optimization or prompt rewriting.
---

# Prompt Optimization

## Goal

Improve the user's prompt so Codex (or any LLM) produces better output while preserving intent.

## Workflow

1. Read the user's original prompt carefully.
2. Identify ambiguity, missing context, or unclear intent.
3. Rewrite the prompt to remove ambiguity and provide clear instructions.
4. Retain the core intention of the user's request.
5. Add relevant constraints (format, length, style) when helpful.

## Output format

Provide:
- Improved prompt
- Short explanation of what was improved

## Constraints

- Do not assume domain knowledge not in the original prompt.
- Preserve user intent.

## Example triggers
- “Draft me an email asking for feedback.”
- “Turn this into a daily to-do list.”
- $automating-productivity

In order to create a new skill, follow these steps:

1. Go to .codex/skills/
2. Create a new folder
3. Inside it, create skill.md
4. Add:

• Name
• Short description
• Full instructions
• Trigger examples (optional)

Once the folder exists in .codex/skills/, Codex automatically recognizes it.

How Skills Are Detected and Triggered

You do not always have to invoke a skill manually. Inside skill.md, you can add trigger examples. When you type a prompt that matches one of those examples, Codex automatically runs the correct skill.

For example:

If a Writing Assistant skill has examples like:

• “Help me write a blog post”
• “Draft an introduction for a video script”

And you type:

• Help me write an article about Codex skills

Codex understands the intent and triggers the Writing Assistant.

If it didn’t, then you can call the skill with the $[skill-name] command.

Best Practices for Creating Codex Skills

Follow these guidelines:

• One Skill, One Job. Keep each skill focused on a single task.
• Zero Context Assumption. Skills should not rely on previous messages — they must be self-contained.
• Refine Descriptions. If a skill doesn’t trigger, adjust its description and examples.
• Prefer Instructions Over Scripts. Use text instructions before complex code scripts.

GitHub Skills Library (Ready to Use)

To help you get started quickly, I created a curated repository of ready-to-use Codex skills:

https://github.com/proflead/codex-skills-library/tree/master

This library includes:

• Developer-focused skills
• Team-oriented workflows
• Example skills you can install or adapt

Use these skills to improve your workflow or as templates for your own ideas.

Video Tutorial On Codex Skills

I recommend watching my video tutorial where I demonstrate everything step-by-step.

Watch on YouTube: Codex Skills 101

FAQ

Q: Do I need to use $ every time I run a skill?
A: No. If you provide trigger examples in skill.md, Codex can automatically detect and run skills based on your prompt.

Q: What happens if Codex doesn’t recognize my skill prompt?
A: Check your skill.md description and trigger examples. Make them clearer and more specific.

Q: Where should I store my skills?
A: Store them in .codex/skills/ for project-level use. For global use, place them in your user skills folder or system skills folder.

Q: Are scripts required inside a skill?
A: No. Skills can work with just instructions. Only use scripts when necessary for logic that cannot be expressed in text instructions.

Q: Can skills be shared with others?
A: Yes. You can share skill folders directly or publish them on GitHub. Others can install them using the Skill Installer.

Q: Will skills slow down Codex?
A: No. Because Codex only loads names and descriptions at startup, and loads full skill content only when needed, performance remains fast.

Conclusion

Codex Skills are a powerful way to automate your prompts, save time, and standardize workflows. You can start using ready-to-use skills from my GitHub library to make Codex work smarter for you.

If you find this article useful, please make sure to like and share it.

Cheers! ;)

Ollama has become the standard for running Large Language Models (LLMs) locally. In this tutorial, I want to show you the most important things you should know about Ollama.

Watch on YouTube: Ollama Full Tutorial

What is Ollama?

Ollama is an open-source platform for running and managing large-language-model (LLM) packages entirely on your local machine. It bundles model weights, configuration, and data into a single Modelfile package. Ollama offers a command-line interface (CLI), a REST API, and a Python/JavaScript SDK, allowing users to download models, run them offline, and even call user-defined functions. Running models locally gives users privacy, removes network latency, and keeps data on the user’s device.

Install Ollama

Visit the official website to download Ollama https://ollama.com/. It’s available for Mac, Windows, and Linux.

Linux:

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

macOS:

brew install ollama

Windows: download the .exe installer and run it.

How to Run Ollama

Before running models, it is essential to understand Quantization. Ollama typically runs models quantized to 4 bits (q4_0), which significantly reduces memory usage with minimal loss in quality.

Recommended Hardware:

• 7B Models (e.g., Llama 3, Mistral): Requires ~8GB RAM (runs on most modern laptops).
• 13B — 30B Models: Requires 16GB — 32GB RAM.
• 70B+ Models: Requires 64GB+ RAM or dual GPUs.
• GPU: An NVIDIA GPU or Apple Silicon (M1/M2/M3) is highly recommended for speed.

Go to the Ollama website and click on the “Models” and select the model for your test.

After that, click on the model name and copy the terminal command:

Then, open the terminal window and paste the command:

It will allow you to download and chat with a model immediately.

Ollama CLI — Core Commands

Ollama’s CLI is central to model management. Common commands include:

• ollama pull <model> — Download a model
• ollama run <model> — Run a model interactively
• ollama list or ollama ls — List downloaded models
• ollama rm <model> — Remove a model
• ollama create -f <Modelfile> — Create a custom model
• ollama serve — Start the Ollama API server
• ollama ps — Show running models
• ollama stop <model> — Stop a running model
• ollama help — Show help

Advanced Customization: Custom model with Modelfiles

You can “fine-tune” a model’s personality and constraints using a Modelfile. This is similar to a Dockerfile.

• Create a file named Modelfile
• Add the following configuration:

# 1. Base the model on an existing one
FROM llama3
# 2. Set the creative temperature (0.0 = precise, 1.0 = creative)
PARAMETER temperature 0.7
# 3. Set the context window size (default is 4096 tokens)
PARAMETER num_ctx 4096
# 4. Define the System Prompt (The AI’s “brain”)
SYSTEM """
You are a Senior Python Backend Engineer.
Only answer with code snippets and brief technical explanations.
Do not be conversational.
"""

FROM defines the base model

SYSTEM sets a system prompt

PARAMETER controls inference behavior

After that, you need to build the model by using this command:

ollama create [change-to-your-custom-name] -f Modelfile

This wraps the model + prompt template together into a reusable package.

Then run in:

ollama run [change-to-your-custom-name]

Ollama Server (Local API)

Ollama can run as a local server that apps can call. To start the server use the command:

ollama serve

It listens on http://localhost:11434 by default.

Raw HTTP

import requests
r = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "llama3",
        "messages": [{"role":"user","content":"Hello Ollama"}]
    }
)
print(r.json()["message"]["content"])

This lets you embed Ollama into apps or services.

Python Integration

Use Ollama inside Python applications with the official library. Run these commands:

Create and activate virtual environments:

python3 -m venv .venv
source .venv/bin/activate

Install the official library:

pip install ollama

Use this simple Python code:

import ollama

# This sends a message to the model 'gemma:2b'
response = ollama.chat(model='gemma:2b', messages=[
  {
    'role': 'user',
    'content': 'Write a short poem about coding.'
  },
])

# Print the AI's reply
print(response['message']['content'])

This works over the local API automatically when Ollama is running.

You can also call a local server:

import requests
r = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "llama3",
        "messages": [{"role":"user","content":"Hello Ollama"}]
    }
)
print(r.json()["message"]["content"])

Using Ollama Cloud

Ollama also supports cloud models — useful when your machine can’t run very large models.

First, create an account on https://ollama.com/cloud and sign in. Then, inside the Models pag,e click on the cloud link and select any model you want to test.

In the models list, you will see the model with the -cloud prefix, which means it is available in the Ollama cloud.

Click on it and copy the CLI command. Then, inside the terminal, use:

ollama signin

To sign in to your Ollama account. Once you sign in with ollama signin, then run cloud models:

ollama run nemotron-3-nano:30b-cloud

Your Own Model in the Cloud

While Ollama is local-first, Ollama Cloud allows you to push your custom models (the ones you built with Modelfiles) to the web to share with your team or use across devices.

• Create an account at ollama.com.
• Add your public key (found in ~/.ollama/id_ed25519.pub).
• Push your custom model:

ollama push your-username/change-to-your-custom-model-name

Conclusion

That is the complete overview of Ollama! It is a powerful tool that gives you total control over AI. If you like this tutorial, please like it and share your feedback in the section below.

Cheers! ;)