DEV Community: EffessDev

Moving from Arduino to ESP-IDF? Start by Blinking an LED

EffessDev — Tue, 06 Oct 2026 15:08:30 +0000

Sidenote: Hi! I've been working on a 100% free & ad-free embedded systems course for a while now, focusing on ESP32 and the native ESP-IDF framework. It skips the stuff AI already does well and focuses strictly on what AI still struggles with. This is the 3rd chapter. I'd love to get your feedback and suggestions. You can also read the latest version of this chapter on the course website if you want to refer to earlier chapters for full context.

Enjoy reading! ☺️

Blinking an LED

Let's have a look at our ESP32 microcontroller:

As you can see, there are a lot of pins underneath it. These are called GPIO pins (General Purpose Input Output pins). These pins are the primary way in which the ESP32 control external hardware. Each pin can be turned HIGH voltage or LOW voltage.

What we are going to now is to make the GPIO22 pin HIGH and LOW continuously (like it's blinking), and connect an LED to that pin so it will turn ON and OFF. No need to worry about why we chose GPIO22 for now.

Create a new empty project

Create a new empty project using the sample_project template. We covered it in this chapter: Your first project. But try to do it yourself without looking.

Write the code

// Include required headers
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"

void app_main(void)
{
    // Clean up previous configuration
    gpio_reset_pin(GPIO22);

    // Configure the pin for voltage output
    gpio_set_direction(GPIO22, GPIO_MODE_OUTPUT);

    // Store the current state (0 = OFF, 1 = ON)
    uint8_t state = 0;

    ESP_LOGI("MAIN", "Starting LED...")

    // Infinite loop
    while (1) {
        // Set GPIO level (0 = OFF, 1 = ON)
        gpio_set_level(GPIO22, state);

        // Log the current state
        ESP_LOGI("MAIN", "LED State: %s", state ? "ON" : "OFF");

        // Toggle state for next iteration
        state = !state;

        // Stop execution for 1000 ms (1 second)
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Here, pdMS_TO_TICKS is a function-like macro that converts milliseconds to ticks. vTaskDelay only accepts ticks.

Improving the code

GPIO_NUM22 and the TAG are used in multiple parts of the code. It's better to define them in the top of the file, rather than repeating it each time:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"

#define BLINK_GPIO GPIO_NUM_22 // object-like macro to define gpio to be blinked

static const char *TAG = "MAIN"; // used for logging

void app_main(void)
{
    gpio_reset_pin(BLINK_GPIO);
    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);

    uint8_t state = 0;

    ESP_LOGI(TAG, "Starting LED...")

    while (1) {
        gpio_set_level(BLINK_GPIO, state);
        ESP_LOGI(TAG, "LED State: %s", state ? "ON" : "OFF");

        state = !state;

        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

Build & flash

We covered this in previous chapters. Do you still remember it?

??? question "How to build the project"
Run the ESP-IDF: Build Your Project command from the command palette.

??? question "How to flash the project"
Refer the following section: Your First Project - Flashing

Connect your LED

Now, your GPIO22 pin must be turning ON and OFF repeatedly. But we can't see it yet. Time to set up the circuit:

Connect the positive terminal of your LED to GPIO22 (labelled as D22).
Connect the negative terminal of your LED to a 220 Ω to 330 Ω resistor (this is important; without a resistor, you might damage your microcontroller).
Connect the other end of the resistor to the GND pin (ground pin) in the ESP32.

Now, you should see your LED blinking. Congrats!

Thanks so much for reading it till the end. If you are an embedded systems developer yourself, I'd love to hear your feedback. Feel free to point out my mistakes and give suggestions. I am all ears.

If you appreciate what I am doing, dropping a ⭐ on GitHub, reacting to this post, or writing a comment will genuinely help a lot with the visibility of the course.

You can find the full course here: https://effessdev.github.io/esp-idf

Thanks for your support ☺️

Did you know you can add images to your GitHub Pages website for FREE without LFS or third-party image servers?

EffessDev — Tue, 06 Oct 2026 13:28:49 +0000

I recently found a surprisingly useful hidden feature of GitHub.

You might want images on your static GitHub Pages site, but you probably don't want to commit them directly since they would bloat your repo. You also cannot use LFS because it won't work out of the box with GitHub Pages. Even though you can use a custom GitHub Action to fetch the LFS files before deployment, that will consume your monthly LFS credits.

I have been looking into third-party image servers lately so I can upload my image there and use that link on my website. But I hadn't thought that GitHub already has one; it's just not obvious.

If you drag and drop an image file into a Markdown file in your repository on GitHub.com, you get a link to the image like this:

My website already uses Markdown for its content. So it's as straightforward as it can get, except I have to go to GitHub.com to upload my images. But I will have to do something similar if I had to use a third-party image server anyway. What I do now is edit my Markdown files from my PC, but leave placeholders for images that I later upload from GitHub.com.

Maybe it's just me who didn't think about this all the time. I was planning to add my credit card for that free tier from Cloudflare. That's when this idea popped up. It surprisingly works quite well! Just posting here hoping it might help somebody else too.

One gotcha to watch out for: Once you upload an image, you cannot easily delete it. I learned this only today.

Thanks for reading ☺️

GiffyPy: A fast, lightweight video editor to crop and trim screen recordings for your README

EffessDev — Tue, 06 Oct 2026 12:21:30 +0000

Note: The latest version includes changes to the export UI as well as a few new features. Please check the README for the latest info.

If you've ever tried adding a GIF or animated WebP of a screen recording to your project's README, you know how annoying it can be. You just want to show people how your product works without spending 20 minutes editing a video, but a few friction points always pop up.

A good README is important. Seeing an app in action builds way more trust than a wall of text. So I built a lightweight video editor called GiffyPy specifically to fix this workflow.

Here are the main issues it solves (or click here to skip directly to the GitHub repository):

1. Removing the taskbar and black borders

In OBS Studio, even if you use Window Capture, you often end up with black bars or the taskbar stuck in the recording:

This happens because OBS forces a specific output resolution instead of locking to the recorded window. Cropping it cleanly in a regular video editor like DaVinci Resolve requires trial and error with resolutions. GiffyPy lets you drag a box and crop your video like an image.

2. Opening instantly and fast seeking

I usually only need to trim the ends and cut out a few middle parts. Waiting for a heavy editor like Clipchamp to load takes longer than the edit itself.

GiffyPy opens in under a second. To keep scrubbing fast, it generates a low-res image sequence during opening the file. When you move the playhead, it switches to the image. When you let go of the mouse, it swaps back to the full-res frame. So unlike Clipchamp, no loading screens while seeking.

3. Optimization

You adjust frame rate, resolution, and quality sliders so your video stays lightweight.

4. Fast exports

Exporting doesn't show a File Explorer pop-up every time. You can either overwrite the original file directly or save a numbered copy.

I'm also planning to add a "Copy to Clipboard" button so you can paste WebP/GIF files directly into READMEs or DEV.to posts. You can check the repo README for the latest updates.

5. Multiple export formats

It currently supports animated WebP, GIF, MP4, WebM, MOV, and MKV.

6. Custom app icon

Not a big feature. But an icon in the taskbar is very important for me:

How it was made

It's built using Python and PySide6. You can check out the code on GitHub:

👉 effessdev/GiffyPy

Note: It requires FFmpeg to work. On Windows, you can install it via the command prompt:

winget install Gyan.FFmpeg

A question on PyInstaller

While opening a video file, the app briefly freezes while loading. This doesn't happen when I run main.py directly, only in the packaged .exe version built with PyInstaller.

Has anyone run into this issue with PyInstaller and PySide6/Qt before? I have no idea why this happens.

What features should I add next?

It largely ticks all my personal boxes right now, but I'd love to know what features would make this more useful for everyone. What should I work on next?

ESP32 Embedded Systems Course Chapter 2: Your First Project

EffessDev — Sun, 04 Oct 2026 15:14:40 +0000

Sidenote: Hi! I've been working on a free, ad-free course on ESP32 and the native ESP-IDF framework for a while now. It skips the stuff AI already does well and focuses strictly on what AI still struggles with. Here is the new chapter! I'd love to get your feedback and suggestions. You can also read the latest version of this chapter on the course website if you want to refer to earlier chapters for full context.

Enjoy reading! ☺️

Your first project

Hardware required:

An ESP32 microcontroller.
A suitable cable to connect it to your PC.

Create a new empty project

We are going to use the ESP-IDF: New Project command from the command palette to create the project.

Open the command palette (I hope you remember the shortcut)
Search for and click on ESP-IDF: New Project, and wait.
Select your ESP-IDF version (you might see only one version since we only installed one), and wait.
A new tab will pop up. Inside that tab, under ESP-IDF Templates, select the sample_project template and click the "Create Project" button.

The tab will refresh, and you will see a form to fill in your project details. Fill in the details:

Project name: Your project name.
Project directory: Your project directory.
ESP-IDF target: esp32.
ESP-IDF board: Custom board.
Serial port: Detect.
OpenOCD configuration files: Keep the default value.
ESP-IDF component directory: Keep the input empty.

Click "Create Project" and wait again. After creation, in the new tab that pops up, click "Open Project". This will open your brand new ESP-IDF project in a fresh VS Code window.

!!! note "If you are using Clangd"
If you are using Clangd instead of the Microsoft C/C++ extension, run ESP-IDF: Configure project for ESP-Clang from the VS Code command palette to make sure Clangd IntelliSense works correctly. Also, make sure both of them aren't activated at the same time, as they can interfere with each other.

Configure your project

You need to configure your project whenever you:

Start a new project (like we did now)
Add, remove, or rename source code files
And so on.

But it's safe to do again and again. Since we just created a new project, let's run it by clicking the ESP-IDF: Run idf.py reconfigure Task command from the command palette.

This will take some time. While it's working, let's learn what it does:

Generates (or regenerates) the build files in the build folder
Generates compile_commands.json, which is essential for Microsoft C/C++ Extension or Clangd to provide IntelliSense
And a lot more (just know these two for now)

Let's write some code

If you look at main.c right now, you will see an empty main function (app_main):

#include <stdio.h>

void app_main(void)
{

}

Let's log "Hello world!" inside it.

Hello, world!

We use a function called ESP_LOGI() to log "Hello world!" (I stands for "info"). Include the esp_log.h header to use that function. The function takes two arguments: a TAG, and the actual string to log.

#include "esp_log.h"

void app_main(void) {
  ESP_LOGI("MAIN", "Hello world!");
}

This code will log something like this:

I (312) MAIN: Hello world!

Here,

I: Log level indicator (Info).
(312): Timestamp in milliseconds since boot (this exact number will vary).
MAIN: Tag name (useful to determine the source of the LOG message when we have a lot of them).
Hello world!: The actual content.

Building (compiling) the project

Open the command palette (Ctrl + Shift + P) and run

ESP-IDF: Build Your Project

This will also take some time. Be patient.

Flashing your project {#flashing}

Flashing is like uploading the compiled code to your ESP32. You need to physically connect the ESP32 to your computer. After doing that, run the following command from the command palette:

ESP-IDF: Flash (UART) Your Project

It probably won't work out of the box. The fix differs depending on your platform.

If you are using Windows

If you are on Windows, flashing might show this error:

A fatal error occurred: Could not connect to an Espressif device on any of the 1 available serial ports.

If that happens, the next time you try, press and hold the BOOT button on your board as soon as you see Connecting.... After some time, the Connecting... will stop and you will see several different outputs. Stop holding the BOOT button when you see these somewhere:

Uploading stub flasher...
Running stub flasher...
Stub flasher running.

It might require some trial and error to find out how long you will have to hold the BOOT button.

If you are using Linux (e.g., Ubuntu)

You might get this error while flashing:

A fatal error occurred: Could not open /dev/ttyUSB0, the port is busy or doesn't exist.
([Errno 13] could not open port /dev/ttyUSB0: [Errno 13] Permission denied: '/dev/ttyUSB0')

Hint: Try to add the user to the dialout or uucp group.

If that happens, run this command, log out, log back in (or reboot), and try flashing again:

sudo usermod -aG dialout $USER

You have to do it only once per system. Subsequent flashing will work without running this command.

Monitoring the device

You should keep your ESP32 connected to your computer so that it receives power and is running. Let's check whether the "Hello world!" got logged.

At the bottom of VS Code, you will see several icons. Find the icon that looks like a monitor and hover over it. If you see "Monitor Device" when you hover, you found the correct icon.

Click on that icon. You will see several logs popping up. These are sent internally. But among those log messages, you will find our Hello world:

I (258) main_task: Started on CPU0
I (258) main_task: Calling app_main()
I (258) MAIN: Hello world!   <--------------- this
I (258) main_task: Returned from app_main()

You might see different numbers than 258. That's not a problem.

So, congratulations! You just set up your computer for ESP-IDF, created a new project, wrote some code, compiled, flashed, and monitored the output!

Tips

Adding the VS Code Configuration Folder

If you accidentally deleted/edited the .vscode folder, you can regenerate it using the ESP-IDF: Add VS Code Configuration Folder command from the command palette.

Test Your Knowledge

Test your knowledge by answering the following questions:

How do we create a new ESP-IDF project? Which template should we use for an empty project?
When do we need to configure our project? How can we do it? Is it safe to do it repeatedly?
What does the "I" in ESP_LOGI stand for?
How do we build an ESP-IDF project?
How do we flash an ESP-IDF project to the ESP32?
What is monitoring? How can we do it?

Thanks so much for reading it till the end. If you are an embedded systems developer yourself, I'd love to hear your feedback. Feel free to point out my mistakes and give suggestions. I am all ears.

If you appreciate what I am doing, dropping a ⭐ on GitHub, reacting to this post, or writing a comment will genuinely help a lot with the visibility of the course.

You can find the full course here: https://effessdev.github.io/esp-idf

Thanks for your support ☺️

Graduating in 2030: Is learning C worth it? Honestly?

EffessDev — Fri, 02 Oct 2026 12:03:47 +0000

I started my degree just 1-2 months ago, which means I will be graduating in 2030. Given how rapidly things are moving, will manual coding (or even manual code review) still be a required skill by then?

I’ve been reading several articles discussing how AI is already outperforming devs at writing code, such as this one by Sylwia Laskowska:

AI Is Already Better at Coding Than Most Software Developers

I largely agree. AI is already extremely capable, and it will only become far more advanced over the next four years.

Lately, I’ve been trying to learn ESP-IDF to program microcontrollers, but C has a brutal learning curve. I spend a significant amount of time just trying to understand the documentation and the official examples, both of which feel drastically more complicated than the documentation I was used to in web development (like Next.js and React).

While I can use AI to generate code and finish projects much faster, my limited C knowledge makes it very difficult for me to properly review or verify the generated output. I am actively trying to fill this knowledge gap, but the process is extremely time-consuming. This leaves me worried that I am spending massive effort mastering a skill that will be useless by the time I enter the workforce.

Why spend years struggling through syntax if AI will always write code better and faster than any human can?

Some people say that it's us who should step in when AI makes a mistake. But what if we make more mistakes than AI?

Looking around developer discussions, the sentiment seems consistent: devs are increasingly shifting away from manual coding toward higher-level tasks. I’ve even seen developers claim they don't even look at AI-generated code anymore, making it feel like even code review itself is ceasing to exist.

I need an updated, realistic perspective on this problem:

Should I stop spending my time deeply learning C programming and syntax?
If I should stop, what should I prioritize instead?

I Stripped Shadcn and Tweakcn. Now My Website Finally Feels Right.

EffessDev — Fri, 02 Oct 2026 05:52:11 +0000

I always use Next.js to build my website.

People say that using Shadcn really speeds up the process. So, I have been using it for almost all the websites I create.

But I think I was overcomplicating my websites for no reason.

To be straight, I am not a web developer. What I consider to be complicated might not be complicated for others. Anyway, this time, what I wanted was a website where I could publish my tutorials, with better syntax highlighting, LaTeX, use whatever Markdown editor I prefer, and have version control for my tutorials (some things are not available here).

The problem with shadcn that I encountered was that it felt too generic.

The easiest way to make it unique is to update the color palette.

But this is the color palette Shadcn uses:

Plus their dark mode versions.

There is no way to update this color palette to match my icon myself without spending a significant amount of time on this. I don't even know what where each one of them are used. While it's not required to edit every single one of these colors, I didn't feel comfortable leaving unused colors with default values.

So, I went to tweakcn.com and grabbed the theme that looked the most like my icon (Polaris).

But honestly, it didn't quite match what I wanted. Whenever I try to change a single color somewhere, it breaks something else.

So, I decided to step back and strip Shadcn entirely.

The new color palette only contains 12 colors (24 if you include dark mode), and they are directly based on my icon. None of those colors are unused.

Another problem I encountered is that the radius of the cards and other things didn't change when I updated the --radius in globals.css, which was really frustrating. Things that happen because of my limited expertise.

Anyway, all things are sorted out right now. The site is much simpler and smaller than before, and I am really satisfied with the look (especially the dark mode). Finally, I can now focus on the actual content.

If there are any frontend developers here, I'd love to hear your feedback. Here is the link to the website:

https://effessdev.github.io

This redesign taught me why sometimes, less is more. What do you think about this one? Have you had any similar experiences where you had to strip down features to make your code less overwhelming?

GiffyPy: A Video Editor Specifically Made for DEV.to Writers

EffessDev — Wed, 30 Sep 2026 15:46:54 +0000

Note: The latest version includes changes to the export UI as well as a few new features. Please check the README for the latest info.

How many times have you taken a screen recording and wished you could quickly crop the taskbar down there, trim the start and end so no one sees you opening OBS Studio, cut and delete the part where you fell asleep, export it as an optimized animated GIF or WebP, and drag and drop it directly to your DEV.to post?

Opening DaVinci Resolve for this purpose is overkill. Even if you open it anyway, you will not be able to crop your video like this:

In my opinion, this is the most useful feature of this app. Many video editors force you to pick a canvas resolution and won't allow you to change it this way.

But other than that, it also supports the following features (note: these features were written by Gemini):

Non-Destructive Multi-Clip Timeline:
- Split video segments anywhere (S key).
- Drag and drop clips to reorder them on the fly.
- Drag clip edges to trim start and end points with live preview.
Flexible Export Options:
- Export to WebP, GIF, MP4, WebM, MOV, or MKV.
- Adjust framerate (0.5 to 60 FPS), scaling/resolution %, and quality settings (automatic palette generation with dither controls for GIFs).
Fast Timeline Navigation & Controls:
- Scroll, zoom (Ctrl + Wheel), and pan (Middle-click drag) through complex timelines.
- Frame-by-frame navigation using arrow keys.
Seamless Preview:
- Automatic background proxy generation for codecs not natively supported by Qt.

As of now, it works, and it is useful. I have tested it quite a bit and fixed many issues. But still, it is not a polished product yet, and it requires FFmpeg to work. Installing FFmpeg is very easy. In Windows, just run winget install Gyan.FFmpeg.

I have opened a few issues myself. They contain a few things I have tried (but couldn't do), and also things that I'll add in the future:

https://github.com/effessdev/GiffyPy/issues

The app is made using Python and PySide6. Here is a link to the GitHub Repo:

https://github.com/effessdev/GiffyPy

Now, do you find this useful? Have you been through this kind of friction before while writing in DEV? I'd love to hear your thoughts!

I Let Free Web Gemini Code My Terrarium, and Now the Worms are Having an Identity Crisis

EffessDev — Mon, 28 Sep 2026 11:14:04 +0000

I built a terrarium simulation using Pygame a while back:

Let's check whether Gemini can add entirely new features to this Python codebase without blowing everything up.

Let's open up the project in VS Code:

I am using ReptClip for VS Code (an extension I built) to build the context and apply the diffs.

Let's addREADME.md, requirements.txt, and all Python files into the context (I know it's not ideal, but let's try):

Already 64,000 tokens. Let's paste it in:

What? The browser chat UI silently truncated the context I pasted in, without showing a single warning!

Luckily, the limit is larger if you upload the context as a file:

Let's type the prompt and hit send!

A 108-line diff. Now, I can copy the diffs and click Apply Diffs in my extension. It will automatically read them from the clipboard and apply the changes:

Let's try once more:

Even though ReptClip supports fuzzy matching in SEARCH blocks, the AI hallucinated too much, so the extension wasn't able to find a match.

Here is my new plan:

Give the AI only the project structure, README, and requirements.txt
Ask it which files it needs to see to implement the feature

It gave a list of the files it wants to see:

Since we already added the project structure and output format, let's uncheck them and add the files Gemini asked for:

Luckily, this time it didn't get truncated:

The new diff was 165 lines:

Let's apply the diffs:

Only one fuzzy match. Let's launch the terrarium:

There we go! We got the feature we asked for.

Time to make it harder. The new feature:

A suspiciously tiny diff that literally fits into a single screenshot:

I applied it anyway:

And ran the simulation:

The worms looked a bit different, but it was definitely far from what I asked. Let's try again with Gemini Pro.

It's using some big words:

It gave me a 265-line diff modifying 2 files. Let's see what it did.

I can't even see the worms.

I thought maybe they were still growing. I waited in front of the simulation at 8x speed for days*:

Still empty. Let's try with Gemini Extended Thinking:

According to Gemini, it found the exact bug:

I applied its recommended patch:

Still no worms.

Let me handle this alone without taking a screenshot every 5 seconds. I'll come back soon.

🏃 ...

So, according to Gemini, this was the reason:

Anyway, I gave it ant.py so it could refer to it and generate proper diffs. This time, I was able to see something!

Now THAT is what actual peristalsis looks like!

I think that's enough for now without breaking it even more.

ReptClip: A VS Code Extension to Paste Your Project into Free Chatbots and Apply the Diffs in One Click

EffessDev — Sat, 26 Sep 2026 12:01:15 +0000

Let me show exactly how it works with an example 🛻

The extension adds a new "ReptClip" tab in the VS Code bottom panel:

I am going to use this extension to redesign my website's landing page. First, we need to prepare the context.

Specify which files to add to the context in the "Files to include" input. You can use glob patterns like **/*.ts.

Since I want to update the landing page, let's add page.tsx. You will get suggestions as you type:

Click "Enter" or "Tab" to accept the suggestion:

If it matches any files, it will turn green. Otherwise, it will turn yellow.

Let's add AGENTS.md too:

This order is preserved in the context output. page.tsx will appear after AGENTS.md.

Now, click "Enter" again. The context will be copied directly to your clipboard. It looks something like this:

# Project structure

```
.gitattributes
.gitignore
AGENTS.md
CONTRIBUTING.md
LICENSE
README.md
pipxclip-config.toml
pyproject.toml
src/pipxclip/__init__.py
src/pipxclip/cli.py
src/pipxclip/config.py
tests/test_cli.py
tests/test_config.py
```

# Output format

Provide all file modifications as Search/Replace blocks inside a single 4-backtick code block.

## Formatting Rules

1. **File Headers:** Every set of edits must begin with the exact relative file path on its own line (e.g., `path/to/file.ext`), even if there is only a single file in the project.
2. **Exact Matching:** The `SEARCH` block must contain an *exact, verbatim* copy of existing code, including identical whitespace, indentation, and surrounding context lines to uniquely identify the match.
3. **Uniqueness:** Provide sufficient surrounding unchanged lines in the `SEARCH` block to ensure it matches exactly **one** location in the target file.
4. **New Files & Deletions:**
   - To create a new file, use an empty `SEARCH` block.
   - To delete a file or a code block, use an empty `REPLACE` block.
5. **No Placeholders:** Do not use ellipses (`...`), comments like `# rest of code unchanged`, or omitted lines inside `SEARCH` or `REPLACE` blocks.
6. **Sequential Edits:** If editing multiple parts of the same file, list the `SEARCH/REPLACE` blocks in top-to-bottom order as they appear in the file.

## Example

````
src/models/user.py
<<<<<<< SEARCH
class User:
    def __init__(self, name):
        self.name = name

    def to_dict(self):
        return {"name": self.name}
=======
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def to_dict(self):
        return {
            "name": self.name,
            "email": self.email,
        }
>>>>>>> REPLACE

src/controllers/user_controller.py
<<<<<<< SEARCH
from src.models.user import User
=======
from src.models.user import User
from src.utils.validator import validate_email
>>>>>>> REPLACE
<<<<<<< SEARCH
def create_user(name):
    return User(name)
=======
def create_user(name, email):
    validate_email(email)
    return User(name, email)
>>>>>>> REPLACE

src/utils/validator.py
<<<<<<< SEARCH
=======
def validate_email(email):
    if "@" not in email:
        raise ValueError("Invalid email address")
>>>>>>> REPLACE
````

# AGENTS.md

```
Do not make mistakes.
```

# Prompt

<- Cursor lands here. You can quickly start typing.

Now, go to any free chatbot and paste the context using Ctrl + V:

Type your prompt, and send:

The chatbot will generate the diffs inside a code block:

Copy it to your clipboard, and go back to VS Code.

Click "Apply Diffs" in the ReptClip tab. The extension reads the diffs from the clipboard and applies them to the files:

Let's start the development server and check out the new landing page:

The landing page has been redesigned.

If at least one SEARCH block in the diff is faulty (no match, not unique, edits a deleted file, etc.), you'll get this:

It also lets you customize the context:

State is stored on a per-project basis. So, when you come back, your configuration will not be gone or mixed up with other projects.

You can customise the context using the checkboxes. Each section can be toggled ON or OFF. You can also write output to a file (relative and absolute path supported). You can uncheck "Copy to Clipboard" too.

Here are a few edge cases explained:

Files to include **/*.py main.py: All Python files are included, but main.py comes last.
Files to include **/*.py src/**/*.py: All Python files are included, but the Python files in src come last.
Files to include **/*.py, files to exclude secret.py: All Python files are included, except secret.py.

So, that's basically what the extension does. If you liked it, a ⭐ on GitHub would really help A LOT! Please feel free to share it with friends or teammates who are looking for a $0 AI coding setup.

It's inspired by my CLI app PipxClip, which was formerly ReptClip, so I named it ReptClip for VS Code.

Also, please tell me what you think in the comments. It really helps me improve the extension further. Big thanks to @piekwerk and @mansio for their suggestions during development!

Also, thanks to @unitbuilds for informing me about the limited-time free access to Qwen 3.8 Flash in Qoder. It wouldn't have been possible without it.

I purposefully kept the source code minimal and lightweight. Feel free to submit pull requests. I review them every day!

Total cost to build this: $0.

I created this extension specifically to help developers who can't afford paid coding agents, giving everyone access to a smooth AI workflow for free.

Thanks for reading 🙂🎉🎉

Is DEV.to Analytics broken? 🤔

EffessDev — Thu, 24 Sep 2026 12:47:37 +0000

This is the traffic sources graph for a post I created a few hours ago:

It's not just this post. Every single one of my posts is dominated by direct/unknown sources. Is it like that for everyone else in here? Or is it just me? It doesn't make any sense at all.

I Made a VS Code Extension to Copy Your Repo to Your Clipboard as Clean Markdown Context for Your Chatbot

EffessDev — Thu, 24 Sep 2026 10:11:21 +0000

⚠️ NOTE

You are reading a post about an older version of ReptClip. Newer versions automatically apply the generated diffs from your clipboard and add many more features. Check out the GitHub Repository for the most up-to-date details, or read this updated post on DEV.

The UI:

An example output:

# Project structure

```
.gitattributes
.gitignore
AGENTS.md
CONTRIBUTING.md
LICENSE
README.md
assets/preview.webp
docs/me/prompt.md
docs/me/publishing.md
pyproject.toml
reptclip-config.toml
src/reptclip/__init__.py
src/reptclip/cli.py
src/reptclip/cli_parser.py
src/reptclip/clipboard.py
src/reptclip/config.py
src/reptclip/file_reader.py
src/reptclip/filters.py
src/reptclip/git_files.py
src/reptclip/markdown_builder.py
tests/test_cli.py
tests/test_config.py
tests/test_file_reader.py
tests/test_filters.py
tests/test_git_files.py
tests/test_markdown_builder.py
```

# AGENTS.md

```
Do not make mistakes.
```

# Prompt

<- Cursor lands here; you can quickly start typing!

Basically, type whatever you want to copy, then press Enter. Context will be copied straight to your clipboard!

Also, you'll get suggestions as you type:

State is stored on a per-project basis. When you come back, your configuration will too!

It's inspired by my CLI app PipxClip, which was formerly ReptClip. So I named it ReptClip for VS Code.

Here are the key improvements from the CLI version:

No need to provide quotes for glob patterns: This is impossible in the CLI
Get suggestions as you type
Syntax highlighting
Intuitive UI (README not required!)

It's really useful for me because this is my workflow when I finish my GitHub Copilot free credits:

Copy files
Paste them into gemini.google.com
Paste them back

And repeat:

If you also found this helpful, please consider giving a ⭐ on GitHub! It really helps A LOT!

Thank you for reading till the end! Please let me know what you think. I am really curious!

Issues and PRs are welcome too!

I just did something my AI agents couldn't

EffessDev — Sat, 12 Sep 2026 04:30:19 +0000

It is funny how things work out. You can let AI tools try to fix a code problem for days, but nothing works until you finally step in and do it yourself.

I was working on my ESP-IDF project and wanted to organize it better. My goal was to use the standard practice of keeping different pieces of code in a folder named components.

Try #1: Gemini 3.6 Flash

I don't pay for AI, so I use the free web versions. I used a tool I built called ReptClip to copy my project structure and files. Then, I asked the AI which files to move and what new code to put inside them.

I did exactly what the AI said without questioning it. Suddenly, red error lines popped up in my code editor. Soon, the whole file was covered in errors. I told the AI about it.

It gave me new steps, and I just followed them again. It still didn't work.

I did this over and over for hours. I got very mad, called the AI stupid, and reset my working directory to start all over from scratch. I do not know why it failed at such an easy job.

Try #2: Gemini 3.1 Pro

I thought the Pro version of the AI would do a better job. I tried the exact same steps and trusted it completely again. But I ended up with the exact same errors.

Tries #3, #4, #5, ... #n

I lost count of how many times I tried this. I tested Gemini Flash Extended, Gemini Pro Extended, DeepSeek v4 Flash, and DeepSeek v4 Pro. For some reason, absolutely nothing worked. I wasted two whole days doing this.

Try #n + 1

Next, I decided to try GitHub Copilot. I gave it instructions, and it spent about 30 minutes on the task. It finally gave me a nice ✅ emoji and said it was done. I thought my problems were over.

I tried to build my project, but it failed. I looked at my code files, and there were error squiggles everywhere, just like before.

I gave up and left the project alone for a few days.

Try #n + 2

After a break, I came back with a new plan.

I went to gemini.google.com and chose the Pro model. I asked the same question. But this time, I stopped blindly pasting the whole file the AI gave me. Instead, I decided to edit the #include directives and type the CMakeLists.txt files by myself.

When I moved my code into the components folder, I noticed errors on the #include lines. I realized right away that the #include paths were the real issue. I told the AI that I could not add those specific headers. The AI said I needed to add the dependency components in REQUIRES or PRIV_REQUIRES in CMakeLists.txt. Adding those fixed a few headers, but some specific headers still failed.

Finally, I searched on Google to find out exactly which components have the definitions for those specific headers that were causing the issue. The answer was slightly different there.

I changed that one single line of code, and it finally worked! The ONLY problem was that all the AIs put the wrong component name in REQUIRES, and none of them could figure out that was the issue. It is hard to believe I wasted weeks on such a tiny problem.

I skipped over a fair bit of the debugging rabbit hole in this post because I honestly couldn't remember every single twist and turn 😅