Forem: Anthony

Local AI vs. Cloud AI: When to Use Which (A Developer's Guide)

Anthony — Wed, 29 Apr 2026 21:58:28 +0000

Running Gemma on Ollama changed how I think about AI tools. Here's the framework I use to decide when to go local and when to stay in the cloud.

There's a moment every developer hits: you're mid-project, you've been routing everything through ChatGPT or Claude, and you start wondering - do I actually need to send this to an external API? What if I just ran something locally?
I had that moment while working on a security automation pipeline on Parrot OS. Some of the data I was processing wasn't something I wanted to leave my machine. So I spun up Gemma via Ollama, and it handled the task cleanly, no API key, no network latency, no data leaving my environment.
That experience pushed me to think more deliberately about when local models make sense and when cloud AI is the right call. This guide is the framework I landed on.

First: What We Mean by "Local" and "Cloud" AI

Local AI means running a model directly on your machine CPU, GPU, or both. Tools like Ollama make this surprisingly accessible. You pull a model (say, ollama pull gemma3), and you're running inference locally in minutes. No internet required after the initial download.
Cloud AI means hitting an external API like OpenAI, Anthropic, Google, or Groq, where the model runs on their infrastructure, and your data travels to their servers with each request.
Both approaches are mature and genuinely useful. The question is choosing the right one for the right job.

When Local AI Wins

Your data is sensitive
This is the biggest one. Suppose you're processing credentials, internal codebase logic, patient records, legal documents, or anything under an NDA. Using a local is non-negotiable. Cloud providers have privacy policies and (usually) strong security, but data still leaves your machine. Regulated industries often can't accept that tradeoff.
Running Ollama with Gemma or Llama means your prompts and completions never touch an external server. For security tooling, this becomes a critical matter.
You're working offline or in restricted environments
Embedded systems, air-gapped networks, and field deployments without reliable connectivity. Cloud AI is a non-starter. Local models run anywhere your hardware runs.
Even in everyday development, offline capability is underrated. If your workflow depends on an external API and that API goes down (and they actually do go down), your entire pipeline stalls.
You need zero latency
For real-time applications, autocomplete, in-editor suggestions, and streaming analysis cloud round-trip latency add up. Even a 300ms API response feels sluggish when it's happening on every keystroke.
Local inference, especially with smaller quantized models, can run substantially faster for short completions on decent hardware. The tradeoff is model capability, but for constrained tasks, it's often worth it.
You're running repetitive, high-volume tasks
Cloud APIs charge per token. If you're running thousands of summarizations, classifications, or transformations in a batch job, those costs compound fast. Once a local model is set up, that same workload costs you electricity.
For anything that runs on a cron schedule or processes large datasets regularly, local inference almost always wins economically after the initial setup investment.
You want to experiment without cost anxiety
There's a subtle psychological effect to metered APIs: you start second-guessing experiments. "Is this prompt worth the tokens?" Local models remove that friction entirely. You can iterate aggressively, run ablations, and test edge cases with zero cost anxiety.

When Cloud AI Wins

You need frontier model capability
This is where cloud AI has a decisive edge and likely will for a while. GPT-4o, Claude Sonnet, Gemini 1.5 Pro, these models handle complex reasoning, nuanced instruction-following, and long-context tasks at a level that consumer-grade local hardware can't match.
If your task requires genuine reasoning depth, multi-step analysis, code generation across a large codebase, and sophisticated writing, cloud models will outperform local ones on most benchmarks. The gap is closing, but it's real.
You're on constrained hardware
Running a capable local model requires meaningful resources. Gemma 3 runs on modest hardware, but if you want something competitive with Frontier Cloud models, you're looking at 16GB+ of VRAM for good performance, or a modern Apple Silicon Mac with unified memory.
If your machine can't comfortably handle local inference without throttling, you're not actually saving time; you're just moving the bottleneck.
You need multimodal capabilities
Vision, audio transcription, and image generation local multimodal support exists, but is patchier than the cloud equivalents. If your workflow depends on processing images, documents, or audio alongside text, cloud APIs offer more reliable, better-integrated support.
Speed of iteration matters more than cost
For prototyping, for client demos, for moving fast, cloud AI removes all the setup friction. No model management, no hardware tuning, no quantization decisions. You call the API, and it works, with the best available model.
When you're exploring a problem space and don't yet know what you need, the cloud is often the faster path to a useful answer.
You need reliability guarantees
Production systems serving real users need uptime guarantees, failover, and support. Cloud providers offer SLAs. A local model running on your dev machine doesn't.

The Hybrid Approach (What I Actually Do)

In practice, I don't treat this as binary. I use a layered approach:

Local first for anything involving sensitive data, batch processing, or tasks I've already validated.
Cloud for reasoning-heavy tasks where I need frontier model quality, complex debugging, architecture design, and nuanced writing.
Local for the dev loop, quick experiments, prompt iteration, and checking whether an approach is viable before committing to API calls.

Ollama makes this easy. You can run multiple models locally and switch between them based on the task. I keep Gemma running for quick local tasks and route to Claude or GPT-4o when I need the heavy lifting.

Getting Started with Local AI (If You Haven't Yet)

If you're on Linux or macOS, Ollama is the fastest path:

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

# Pull Gemma 3 (good balance of capability and speed)
ollama pull gemma3

# Run it
ollama run gemma3

That's it. You're running local inference. From there, you can integrate via Ollama's OpenAI-compatible API endpoint (http://localhost:11434/v1) into any tool that supports OpenAI's API format — which is most of them.

The Decision Framework

When deciding where to route a task, I ask these four questions in order:

Is the data sensitive? → Local, no exceptions.
Does this require frontier reasoning? → Cloud.
Is this repetitive or high-volume? → Local.
Am I prototyping or moving fast? → Cloud.

Most tasks fall cleanly into one bucket. The cases that don't are usually good candidates for the hybrid approach prototype in the cloud, then migrate to local once the pattern is validated.

Final Thought

Framing "local vs. cloud AI" as a competition misses the point. They solve different problems. Cloud AI gives you access to the most capable models with minimal setup. Local AI gives you control, privacy, and economics that cloud can't match at scale.
The developers who get the most out of both are the ones who stop defaulting to one and start choosing deliberately.

Have a local model setup that works well for you? Drop it in the comments. I'm always curious what other developers are running.

How My VS Code Spawned 15 Copies of Itself and Froze My Entire System (And How I Fixed It)

Anthony — Sat, 11 Apr 2026 17:41:18 +0000

It started innocently. I opened VS Code on my Parrot OS machine to get some work done.
Then my system started lagging.
Then popups appeared.
Then it froze completely.
Then VS Code opened again. And again. And again, until I had 15 stacked dialog boxes all screaming:

"Another instance of Code is running but not responding. Please close all other instances and try again."

Each pop-up was spawning another. My GUI was frozen. I couldn't type. I tried switching to a TTY terminal, but it wouldn't load. I tried Ctrl+Alt+F3 again the whole system restarted.
I genuinely had no idea what was happening.

What Was Actually Going On

After rebooting and doing some serious investigation (with help from both Claude and ChatGPT - yes, I used both, I'll explain), here's the full root cause chain:
1. VS Code crashed mid-session
When it crashed, it left behind corrupted lock files and IPC socket files. These are flags the app sets to say "I'm currently running." A clean exit removes them. A crash doesn't.
2. Next launch saw the lock files
VS Code detected its own ghost, thought another instance was already running, and threw the warning dialog.
3. Session restore made it worse
VS Code has a setting that restores all previously open windows on the next launch. I had 5 windows open when it crashed. So it tried to reopen all 5 simultaneously.
4. GPU acceleration was the silent killer
I'm running an Intel UHD 605 GPU. Electron apps (VS Code is built on Electron, which is essentially a Chromium browser) have known conflicts with Intel Mesa drivers on Debian-based Linux distros. The GPU cache was corrupted, causing VS Code to crash on startup, which triggered the loop again.
5. containerd was piling on
My system had Docker's container runtime (containerd) running in the background. Combined with VS Code's IO-heavy startup, it was hammering my disk simultaneously, making everything worse.

How I Debugged It

I want to be transparent: I was actively using AI during this. I had Claude walk me through log analysis, and I cross-validated with ChatGPT, which added the crucial GPU angle I had missed.
The ChatGPT insight that cracked it: "GPU / rendering crash is VERY COMMON on Parrot + Intel UHD 605. Electron tries GPU → driver glitch → crash → restart loop."
That's what unlocked the full fix.

Here's the exact diagnostic flow:

# Check RAM and swap
free -h && swapon --show

# Check if OOM killer fired
journalctl -b | grep -i "oom\|killed process\|out of memory"

# Check what's running
ps aux --sort=-%cpu | head -10

My RAM was actually fine (5.7GB available). The OOM killer hadn't fired. This ruled out memory exhaustion and pointed clearly toward GPU + lock file corruption.

The Fix (Step by Step)

Step 1 - Kill all VS Code processes
pkill -9 -f code && pkill -9 -f Code
Step 2 - Remove lock and singleton files
rm -rf ~/.config/Code/*.lock rm -rf ~/.config/Code/Singleton*
Step 3 - Clear all cache, including GPU cache
rm -rf ~/.config/Code/Cache rm -rf ~/.config/Code/CachedData rm -rf ~/.config/Code/GPUCache rm -rf /tmp/.code-*
Step 4 - Disable GPU acceleration permanently
nano ~/.config/Code/User/settings.json Add: json{ "disable-hardware-acceleration": true, "window.restoreWindows": "none", "window.reopenFolders": "none" } The window.restoreWindows: none is what stopped the multi-window spawn cascade. VS Code now always opens fresh instead of trying to restore a crashed session.
Step 5 - Make --disable-gpu permanent via argv.json
nano ~/.config/Code/argv.json Add: json{ "disable-hardware-acceleration": true } Now you can click the VS Code icon normally without needing the terminal flag every time.
Step 6 - Test launch
code --disable-gpu
Clean single window. The Extensions are being reinstalled fresh. Problem solved.

Here are My Key Takeaways

VS Code is an Electron app - yes, it's essentially a browser. It inherits all of Chromium's GPU quirks on Linux.
Intel UHD 605 + Mesa drivers + Electron = known bad combo on Debian-based distros. Disable hardware acceleration for VS Code, Discord, and Chrome if you're on this GPU.
Lock files are silent saboteurs. Any crash that doesn't clean up after itself leaves a ghost that haunts your next launch.
Session restore is a trap after a crash. Disable it. Open your files manually.
Using multiple AIs isn't cheating - it's smart. Claude caught the lock file. ChatGPT caught the GPU angle. Cross-validating got me to the full picture faster.
TTY is your emergency exit. Learn Ctrl+Alt+F3 and Ctrl+Alt+F7. When your GUI dies on Linux, TTY is the difference between a 5-minute fix and a full reinstall, lol.

My Setup:

OS: Parrot OS (Debian-based)
GPU: Intel UHD 605
RAM: 8GB
VS Code version: 1.112.0

If this saved your system, drop a reaction. And if you've hit something similar on a different distro, share it in the comments. I'd love to know how it manifested differently.

How to Install and Use Ubuntu on a Virtual Machine

Anthony — Fri, 04 Jul 2025 13:41:35 +0000

What You’ll Need

A computer running Windows 10/11 or macOS
At least 8 GB RAM (16 GB recommended)
10–25 GB free disk space
An internet connection

Step 1: Download Ubuntu ISO

Go to the official Ubuntu site:
Click Download Ubuntu 24.04 LTS

3.Save the .iso file (~4.5 GB) to your computer

Step 2: Install VirtualBox

On Windows 10/11:

1. Go to [](https://www.virtualbox.org/wiki/Downloads)

2. Download Windows hosts

3. Run the installer and follow the prompts (accept defaults)

4. After install, launch VirtualBox

On macOS:

1. Same site  [](https://www.virtualbox.org/wiki/Downloads)

2. Download OS X hosts

3. If installation fails or USB/network support breaks, install Parallels Desktop instead (free trial):
 [](https://www.parallels.com/products/desktop/)

*Step 3: Create the Virtual Machine
*
1. Open VirtualBox, click New

2. Name: Ubuntu 24.04
   Type: Linux
   Version: Ubuntu (64-bit)

3. Click Next

Memory Size:

- Use 4096 MB (4 GB) minimum

Hard Disk:

- Choose Create a virtual hard disk now
- Click Create

Hard Disk File Type:

- Leave as VDI (VirtualBox Disk Image)

Storage:

- Select Dynamically allocated

Disk Size:

Set to 25 GB

Step 4: Mount Ubuntu ISO and Start the VM

1. Select your new VM → click Settings

2. Go to Storage tab

3. Under Controller: IDE, click the empty disk icon

4. On the right, click the disk icon → choose a disk file

5. Select the Ubuntu .iso you downloaded

6. Click OK

Now click Start to launch the VM.

Step 5: Install Ubuntu
Once Ubuntu boots inside the VM:

1. Choose your language → Click Try or Install Ubuntu

2. Click Install Ubuntu

3. Keyboard Layout: Choose or accept default

4. Installation Type: Select Erase disk and install Ubuntu (don’t worry—it only affects the VM, not your real machine)

5. Follow the prompts:

    - Set your time zone

    -  Enter name, computer name, username, and password

6. Click Install Now

7. Wait for installation to complete (~10–20 mins)

8. When prompted, click Restart Now
If it freezes on restart, click Machine → Reset in VirtualBox menu

Step 6: First-Time Use

After reboot:

1. Login with the username/password you created

2. You’ll see the Ubuntu desktop environment

3. Explore basic features:

    - Open Terminal (Ctrl + Alt + T)
    - Launch Firefox
    - Open the file manager
    Shut down via top-right menu

Post-Install Tips (Recommended)

1. Install Guest Additions (for better performance)
In Ubuntu VM:

1. Click Devices → Insert Guest Additions CD image

2. Open the mounted disk on the desktop

3. Right-click inside the folder → Open in Terminal

4. Run:

sudo ./VBoxLinuxAdditions.run

5. Restart the VM

Enables:

- Full-screen resolution

- Shared clipboard (copy-paste)

- Drag-and-drop files

2. Enable Shared Folders (optional)

1. In VirtualBox, go to Settings → Shared Folders

2. Add a new folder from your host system

3. Check Auto-mount and Make Permanent

4. Restart Ubuntu → the folder appears in /media/sf_<foldername>

3. Internet Access

Ubuntu should have internet automatically via NAT.
If not:

- Go to Settings → Network

- Ensure Attached to: NAT is selected

Cleaning Up (Optional)

To free up space on your host:

- Delete unused snapshots

- Unused .iso file after installation

What’s Next?

Now that Ubuntu is installed, here are beginner-friendly tasks:

- Learn Simple Commands such as `ls` `pwd` `cd` `mkdir`

- Try installing software: `sudo apt install gimp`

- Learn about system updates: `sudo apt update && sudo apt upgrade`

- Explore GNOME Settings

Summary

You now have a fully functioning Ubuntu environment inside a safe virtual machine. This is the perfect sandbox to learn Linux without breaking anything on your main OS.

What is Cloud Computing and Why It Matters?

Anthony — Tue, 03 Dec 2024 16:03:11 +0000

What is Cloud Computing and Why It Matters?

Cloud computing is a transformative technology that provides on-demand access to computing resources like servers, storage, applications, and databases over the internet. Instead of relying on local hardware, businesses and individuals can use remote servers hosted in data centers worldwide. This shift to the "cloud" allows for greater flexibility, scalability, and cost-efficiency.

How Cloud Computing Works

Cloud computing is typically categorized into three service models:

Infrastructure as a Service (IaaS): Provides virtualized computing resources like servers and storage.
Infrastructure as a Service (IaaS): Provides virtualized computing resources like servers and storage.
Software as a Service (SaaS): Delivers fully functional applications over the internet (e.g., email or productivity tools).

Cloud services are also delivered via different deployment models:

Public Cloud: Resources are shared across multiple users.
Private Cloud: Dedicated to a single organization for enhanced control and security.
Hybrid Cloud: Combines public and private clouds, offering a balance of flexibility and security.

Why Cloud Computing Matters

Scalability: Cloud platforms allow businesses to scale resources up or down instantly to meet demand, saving time and cost compared to traditional IT infrastructure.
Cost Efficiency: With a pay-as-you-go model, organizations reduce capital expenses on hardware and only pay for what they use.
Accessibility and Collaboration: Cloud services enable global access to data and applications, fostering seamless collaboration across teams.
Enhanced Innovation: Developers can quickly prototype, test, and deploy solutions without investing in hardware.
Data Security and Backup: Modern cloud providers incorporate robust encryption and backup mechanisms, reducing the risk of data loss.
Sustainability: Many cloud providers optimize energy use and leverage renewable energy sources, lowering the environmental impact of computing.

Applications in Various Industries

Healthcare: Facilitates research and secure patient data management.
Finance: Enables real-time analytics and fraud detection.
Retail: Improves customer insights and supply chain operations.
Government: Enhances public service delivery with shared cloud infrastructure.

Understanding Neural Networks and Deep Learning

Anthony — Tue, 03 Dec 2024 09:33:54 +0000

Artificial Intelligence (AI) has revolutionized industries, from healthcare to entertainment, and at its core lies Deep Learning—a subset of AI powered by neural networks. If you’ve ever wondered how your phone recognizes your face or how Netflix recommends your next binge-worthy series, neural networks are the magic behind the curtain.

This guide breaks down the concepts of neural networks and deep learning into digestible chunks to help you grasp the basics.

What Are Neural Networks?
Inspired by the human brain, a neural network is a computational model designed to recognize patterns. Just like neurons in the brain connect and fire together to process information, artificial neural networks consist of nodes (neurons) connected in layers to analyze and interpret data.

Key Components of a Neural Network

Input Layer:
- Accepts raw data (e.g., an image or text).
- Each node in this layer represents a feature of the input.
Hidden Layers:
- Perform computations using mathematical functions to extract patterns.
- The more layers, the "deeper" the network (hence, deep learning).
Output Layer:
- Produces the final prediction or classification (e.g., cat or dog in an image).

How Does Deep Learning Work?

At its core, deep learning uses neural networks with multiple hidden layers to model complex data. It relies on a process called "forward propagation" and "backpropagation":

Forward Propagation:
- Data flows through the network, layer by layer.
- Each neuron applies a function (activation function) to decide whether to "fire" (pass its value forward).
Backpropagation:
- After the initial prediction, the network calculates the error using a "loss function""

The network adjusts its internal parameters (weights) to minimize the error through an optimization algorithm like "gradient descent".

This iterative process continues until the model produces accurate predictions.

Real-World Applications of Neural Networks

Image Recognition:
- Used in facial recognition, medical imaging, and object detection.
- Example: Autonomous vehicles identify road signs and pedestrians.
Natural Language Processing (NLP):
- Powers chatbots, language translation, and sentiment analysis.
- Example: Virtual assistants like Alexa and Siri.
Recommender Systems:
- Suggests products, movies, or music based on user preferences.
- Example: Netflix’s recommendation engine.
Healthcare:
- Assists in diagnosing diseases using patient data and medical images.
- Example: Early detection of cancers using CT scans.

Building a Neural Network: Key Steps

Collect and Prepare Data
Neural networks require large datasets. Data preprocessing (cleaning, normalizing, splitting into training/testing sets) ensures better performance.
Define the Architecture
- Number of layers and neurons.
- Choose activation functions (e.g., ReLU, Sigmoid).
Train the Model
- Use forward and backpropagation to adjust weights.
- Iterate over multiple epochs (training cycles).
Evaluate and Test
- Test the model on unseen data to measure accuracy.
- Adjust parameters if needed to reduce overfitting or underfitting.

Understanding Key Concepts in Deep Learning

Activation Functions: Define the output of neurons. Popular options:
- ReLU (Rectified Linear Unit): Common for hidden layers.
- Sigmoid: Outputs values between 0 and 1 (useful for probabilities).
Overfitting: When the model performs well on training data but poorly on new data. Solution: Use techniques like dropout or regularization.
Optimization Algorithms: Adjust the network's weights to minimize error
Example: Adam Optimizer (widely used).

Getting Started with Deep Learning
If you're eager to dive into deep learning:

Learn Python: It’s the go-to language for deep learning.
Explore Libraries: TensorFlow, PyTorch, and Keras simplify neural network implementation.
Work on Projects: Start with datasets like MNIST or CIFAR-10.

THANK YOU FOR READING.

Introduction to Linux Commands for New Users

Anthony — Fri, 12 Jul 2024 04:00:00 +0000

Linux is a powerful operating system favored by developers, system administrators, and enthusiasts for its flexibility and control. If you're new to Linux, its command-line interface (CLI) might seem intimidating at first. However, learning a few essential commands can unlock a world of possibilities and make your Linux journey much smoother.

This guide introduces some of the most basic Linux commands to help you get started.

Why Use the Command Line?

The Linux command line allows users to interact directly with the operating system. It is:

Efficient: Execute tasks quickly.
Powerful: Perform complex operations not always available in graphical interfaces
Customizable: Tailor workflows to specific needs using scripts and commands.

Getting Started: Opening the Terminal

-Keyboard Shortcut: Press Ctrl + Alt + T or Alt + T (I use Parrot os).

Desktop Menu Section: Look for "Terminal" in the application menu.

Once the terminal is open, you're ready to start!

Essential Linux Commands

1. Navigating the File System

The Linux file system is hierarchical, resembling an inverted tree.

pwd (Print Working Directory)
Displays your current directory.
pwd
ls (List)
Lists the contents of a directory.
ls
Add options like -l for detailed view or -a to show hidden files:
ls -la
cd (Change Directory)
Moves between directories(folder2 becomes the current directory) .
cd /Desktop/folder1/folder2

2. File and Directory Management

mkdir (Make Directory)
Creates a new directory.
mkdir new_folder
touch (Create File)
Creates an empty file.
touch newfile.txt
rm (Remove)
Deletes files or directories.
rm file.txt rm -r folder_name # Deletes a directory
cp (Copy)
Copies files or directories.
cp file.txt /destination/path/
mv (Move)
Moves or renames files.
mv oldfile.txt newfile.txt

3. Viewing and Editing Files

cat (Concatenate)
Displays the content of a file.
cat file.txt
nano/pluma (Editor)
Opens files in a text editor.
nano file.txt
Use Ctrl + O to save and Ctrl + X to exit.

4. System Information

uname
Shows system information.
uname -a
df -h
Displays available disk space.
df -h
top
Monitors running processes.
top
Press q to exit.

5. Getting Help

man (Manual)
Displays the manual for a command.
man ls
--help
Provides a brief overview of a command.
ls --help

Tips for New Users

Practice Regularly: Familiarity comes with use.
Use Tab Completion: Type part of a command or file name and press Tab to auto-complete.
Experiment Safely: Use a virtual machine or a separate environment to try new commands.

Conclusion

Mastering the Linux command line may seem daunting at first, but starting with these foundational commands sets you on the right path. As you grow more comfortable, you'll discover the full potential of Linux and its tools.

Happy learning!