DEV Community: EffessDev

Can I remove the AI-generated tag from my AI-generated course?

EffessDev — Tue, 08 Sep 2026 15:03:01 +0000

I recently used DeepSeek v4 Pro to generate an embedded systems course for app, game, or web developers who want to transition into low-level programming and embedded C. I wrote a hyper-specific prompt and asked the AI to first list the chapters and their content. Then I generated each chapter individually. Right now the course has 10 chapters.

Originally, I created this course for myself, and I've been actively using it. Before studying a new chapter, I paste the content back into an AI to check for factual errors. When something feels unclear or incomplete, I dig deeper by asking questions. Then integrate what I learn back into the course. Once I finish, I plan to have one of my college professors review it for any remaining issues.

To stay transparent, I added an "AI-generated" badge at the top of every chapter. But at this point, I'm questioning whether that label still fits. I've put a lot of personal effort into reviewing, correcting, and expanding the material. The phrase "AI-generated" often implies low effort or minimal human involvement, and I don't think that describes my course anymore.

So here's my question:

Is it fair to change or remove the AI-generated tag after significant human effort?

I'd love to hear how other people handle this, so I haven't asked this to an AI yet.

Getting Started with ESP-IDF in VS Code for ESP32 (Setup Guide • Development Environment Tutorial)

EffessDev — Sat, 29 Aug 2026 03:25:58 +0000

This is a step-by-step tutorial that explains how you can set up your development environment for working with ESP-IDF projects in VS Code.

Install ESP-IDF

Install EIM

Espressif Systems provides a graphical tool called EIM (ESP-IDF Installation Manager) to install ESP-IDF. Click the link below to go to the official page to download EIM:

https://dl.espressif.com/dl/eim/

Make sure you are in the "Online Installer" tab. The exact file to download depends on your system:

Windows: Download eim-gui-windows-x64.exe. Run this installer to install EIM.
Linux x64 (Ubuntu): Download and install the .deb package (eim-gui-linux-x64.deb).

Install ESP-IDF using EIM

Now that we have installed EIM, let's install ESP-IDF using it.

Open EIM.
Under "New Installation" click "Start Installation".
Under "Easy Installation", click "Start Easy Installation" to install the latest stable version of ESP-IDF with default settings.
If there are no problems, you will see the "Ready to Install" page. Click "Start Installation".

Install ESP-IDF VS Code Extension

We use this extension as a high-level wrapper for ESP-IDF. Most times, we do not use ESP-IDF directly. For example, if we need to compile our source code, we ask the extension to do it, which uses the ESP-IDF we just installed internally to to compile the source code.

Install the extension named "ESP-IDF" by "Espressif Systems" in VS Code.

Verify installation

After installing, restart VS Code. Use the shortcut Ctrl + Shift + P to open the command palette (remember this shortcut, we are going to use it a lot). Inside the command palette, search ESP-IDF. You will see many entries which start with ESP-IDF:. Those commands are provided my the ESP-IDF extension. These commands are what we use for almost everything.

Note

If you are not in an ESP-IDF project, you might see this:

No standard ESP-IDF project was found in this workspace. Do you want to activate the ESP-IDF extension anyway?

If you want to use the extension (in this case we do), you should click "Activate Anyway". Then only we can use the extension. If you mistakenly clicked "X", restart VS Code, wait for that to pop up again, and click "Activate Anyway".

Keep this in mind since you might need this in the future.

Creating a New Project

Like I said before, we are going to use the ESP-IDF: New Project command from the command palette to create the project. Press Ctrl + Shift + P to open the command palette.

From the command palette, search 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 which pops up, click "Open Project". This will open your brand new ESP-IDF project in a fresh VS Code window.

If you are prompted to generate compile_commands.json, accept it. If not, or you mistakenly clicked "Decline", do Ctrl + Shift + P -> ESP-IDF: Run idf.py reconfigure Task, which does the same thing. compile_commands.json is essential for Intellisense to work correctly. Otherwise, you will encounter error squiggles everywhere.

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)
Adding, removing, or renaming source files
Adding or changing component dependencies
Fixing corrupted build files
Etc.

But it's safe to do again and again, even if you haven't done anything above or have any problems. Since we just created a new project, let's run it.

Like we did before, we are again going to use the command palette. Open the command palette (do you remember how?), and click Ctrl + Shift + P -> ESP-IDF: Run idf.py reconfigure Task.

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

Generates (or regenerates) the build files
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 and empty main function:

#include <stdio.h>

void app_main(void)
{

}

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

#include "esp_log.h" // Add this header for logging
#include <stdio.h>

// Define a tag for your log messages
static const char *TAG = "MAIN";

void app_main(void) {
  // Log "Hello world!"
  ESP_LOGI(TAG, "Hello world!");
}

Building (compiling) the project

Like we always do, open the command palette and run

ESP-IDF: Build Your Project

This will also take some time. Be patient.

Flashing your project

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 will probably won't work out of the box. The fix differ dipending 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 see several 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 user into 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 comamnd.

Monitoring the device

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

On the bottom of VS Code, you will see several icons. Find the icon which 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 send 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! Next, you can check out the official documentation to learn more about ESP-IDF. I also have some great tutorials which you can read on my website or on DEV.to.

Troubleshooting

Warning: This section is not completed yet.

Red squiggly lines under `#include "something"`

Try both. At least one of them will probably work.

Option 1: Ctrl + Shift + P -> ESP-IDF: Run idf.py reconfigure Task
Option 2: Ctrl + Shift + P -> Add VS Code Configuration Folder

Reconfigure or build failure

Delete the build directory and try again.

Tips

Using `idf.py`

Ctrl + Shift + P -> Open ESP-IDF Terminal. You can use idf.py in this terminal (e.g., idf.py reconfigure).

ESP-IDF Bluetooth LE Beginner Tutorial (BLE)

EffessDev — Fri, 28 Aug 2026 13:30:10 +0000

This tutorial covers the basics of how to use Bluetooth Low Energy (BLE) in your ESP-IDF project. It's based on the official documentation by Espressif Systems.

This is a practical, step-by-step tutorial, focusing on building a conceptual understanding of BLE and its basic code implementation, rather than every single feature in detail. You can follow along from the beginning to the end. After completing this, you will be able to understand the official documentation and the official example.

You can download the full final code here and the full project here, but I recommend you to write the code yourself by following this tutorial instead.

Let's start!

The Setup

I am assuming you have created an empty ESP-IDF project using the sample_project template and verified building and flashing is working properly. If you haven't already, you can check out my tutorial:

Enabling BLE in ESP-IDF

Before you can use BLE, you have to enable it using Menuconfig. There are two ways to do this.

Option 1: Using the VS Code Command Palette

Warning: Only use this option if you are developing using the ESP-IDF VS Code extension.

Click Ctrl + Shift + P to open the command palette.
Search for and select ESP-IDF: SDK Configuration Editor (Menuconfig).
Navigate to Component Config -> Bluetooth.
Check the Bluetooth box and select NimBLE - BLE only from the Host selector.

Option 2: Using the ESP-IDF terminal

Open the project configuration menu by running idf.py menuconfig
Navigate to Component config -> Bluetooth.
Enable Bluetooth by setting Bluetooth to [x] (enabled).
Select the host stack by navigating to Host and choosing NimBLE - BLE only.
Press S to save, then Q to quit.

Updating `CMakeLists.txt`

You should add PRIV_REQUIRES bt nvs_flash esp_driver_gpio in your CMakeLists.txt inside idf_component_register(), since our program requires them.

Including necessary headers

This program requires a lot of headers to be included. Update your main.c like this:

/* Includes */
/* STD APIs */
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>

/* ESP APIs */
#include "driver/gpio.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "sdkconfig.h"

/* FreeRTOS APIs */
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

/* NimBLE stack APIs */
#include "host/ble_hs.h"
#include "host/ble_uuid.h"
#include "host/util/util.h"
#include "nimble/ble.h"
#include "nimble/nimble_port.h"
#include "nimble/nimble_port_freertos.h"
#include "services/gap/ble_svc_gap.h"
#include "services/gatt/ble_svc_gatt.h"

/* Defines */
#define TAG "NimBLE_LED"
#define DEVICE_NAME "NimBLE_LED"

void app_main(void) {
    // Empty for now
}

You can change the TAG and DEVICE_NAME if required. TAG is just a label which we use for logging (we will use it later in the tutorial). DEVICE_NAME is how our ESP32 appears to the other devices (like our phone). Later, we are going to connect your phone to your ESP32. In your phone's "available devices" list, you will see this DEVICE_NAME.

Tips for beginners

We use #define to define macros. Macros are of two types - object-like macros and function-like macros. Here, TAG and DEVICE_NAME are object like macros. For now, let's only consider object-like macros (the ones we are using here).

How it works is that, we define DEVICE_NAME to be "NimBLE_LED" and use DEVICE_NAME like a variable in our code (e.g., we can call a function like this: setDeviceName(DEVICE_NAME)). When we compile our code, before the compilation step begins, the preprocessor literally replaces all instances of DEVICE_NAME with "NimBLE_LED", so the previous function call becomes setDeviceName("NimBLE_LED"). So, it is functionally identical to we directly using the string everywhere.

The main reason why we use it is because the exact same string "NimBLE_LED" will be used in multiple places in our code. If we use #define, we can be 100% sure that it will be identical everywhere. Also, if we want to change the name of our device, we just have to update DEVICE_NAME instead of eveywhere.

Initialize NVS Flash (Non-Volatile Storage)

The BLE stack requires NVS flash to store configurations, so it should be initialized using nvs_flash_init(). You don't need to overthink about it at this point. Just call it in the main function:

void app_main(void) {
    nvs_flash_init();
}

This function returns a return code. If the return code is 0, it means no errors. Any non-zero value means an error, and each value corresponds to a particular error. To make our code bulletproof, let's add some error handling:

void app_main(void) {
  esp_err_t ret; // To store the return code

  ret = nvs_flash_init();
  if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
      ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
    ESP_ERROR_CHECK(nvs_flash_erase());
    ret = nvs_flash_init();
  }
  if (ret != ESP_OK) {
    ESP_LOGE(TAG, "failed to initialize nvs flash, error code: %d ", ret);
    return;
  }
}

Tips for beginners

Here, esp_err_t is just an int, not some mysterious type. It's provided by esp_err.h, which we included in common.h. esp_err_t stands for "ESP Error Type". That alias was defined for code readability.

Similarly, ESP_ERR_NVS_NO_FREE_PAGES, ESP_ERR_NVS_NEW_VERSION_FOUND, etc. are also ints, which are defined in nvs.h. They are object-like macros defined using #define (just like how defined TAG and DEVICE_NAME), which means they will be replaced with their actual values (4365 and 4368 in this case) in the preprocessing step.

ESP_LOGE ("E" stands for "Error") is a function-like macro used to log errors. They are similar to object-like macros, but instead of replacing with an object, it replace with a function. ESP_LOGI is used for logging "Info".

Initialize GPIO2 output pin

Here, we are using GPIO2 because most ESP32s have an inbuilt LED for it.

void app_main() {
    // ...
    gpio_reset_pin(GPIO_NUM_2);
    gpio_set_direction(GPIO_NUM_2, GPIO_MODE_OUTPUT);
}

Initialize NimBLE stack

Call nimble_port_init() to initialize NimBLE, the software stack we are using to manage BLE.

void app_main(void) {
  // ...
  ret = nimble_port_init();
  if (ret != ESP_OK) {
    ESP_LOGE(TAG, "failed to initialize nimble stack, error code: %d ", ret);
    return;
  }
}

Here, we are reusing the ret variable we created earlier.

Initialize GAP

GAP stands for Generic Access Profile. Initializing it makes our ESP32 discoverable to other devices (e.g., our phone).

void app_main(void) {
  // ...
  BaseType_t rc = 0; // Still just an int; "rc" stands for "return code"

  ble_svc_gap_init();

  rc = ble_svc_gap_device_name_set(DEVICE_NAME);
  if (rc != 0) {
    ESP_LOGE(TAG, "failed to set device name to %s, error code: %d",
             DEVICE_NAME, rc);
    return;
  }
}

DEVICE_NAME is defined in common.h. You can change it if you want.

Initialize the GATT profile

This is the hard part. GATT stands for Generic Attribute. It defines how two connected devices package, format, and send data using a structured hierarchy of services and characteristics.

A GATT profile has one or more services, which have one or more characteristics within them, which hold data and descriptors. Each service and characteristic has a UUID. Here is a diagram showing the GATT hierarchy:

+---------------------------+
|          PROFILE          |
+---------------------------+
|                           |
|  +---------------------+  |
|  | SERVICE             |  |
|  +---------------------+  |
|  |                     |  |
|  | CHARACTERISTIC      |  |
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|  |                     |  |
|  |  CHARACTERISTIC     |  |
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|                           |
|  +---------------------+  |
|  | SERVICE             |  |
|  +---------------------+  |
|  |                     |  |
|  | CHARACTERISTIC      |  |  
|  |  - PROPERTIES       |  |
|  |  - VALUE            |  |
|  |  - DESCRIPTOR       |  |
|  |                     |  |
|  +---------------------+  |
|                           |
+---------------------------+

For example, you can create a "Heart Rate" service that has a "Heart Rate Measurement" characteristic, which holds the value.

Before defining our services and characteristics, let's initialize GATT:

void app_main(void) {
  // ...
  ble_svc_gatt_init();
}

Define GATT services table

Here is where we define which services and characteristics our ESP32 have which can be tweaked from our phone. Define these before (outside) the app_main function, but after the #includes:

static const ble_uuid16_t auto_io_svc_uuid = BLE_UUID16_INIT(0x1815);
static const ble_uuid16_t led_chr_uuid = BLE_UUID16_INIT(0x2A56);

static uint16_t led_chr_val_handle;
static int led_chr_access(uint16_t conn_handle, uint16_t attr_handle,
                          struct ble_gatt_access_ctxt *ctxt, void *arg);


/* GATT services table */
static const struct ble_gatt_svc_def gatt_svr_svcs[] = {
    /* Automation IO service */
    {.type = BLE_GATT_SVC_TYPE_PRIMARY,
     .uuid = &auto_io_svc_uuid.u,
     .characteristics =
         (struct ble_gatt_chr_def[]){
             {/* LED characteristic */
              .uuid = &led_chr_uuid.u,
              .access_cb = led_chr_access,
              .flags = BLE_GATT_CHR_F_WRITE,
              .val_handle = &led_chr_val_handle},
             {
                 0, /* No more characteristics in this service. */
             }}},

    {
        0, /* No more services. */
    },
};

You might wonder why we used 0x1815 as the UUID of our Automation IO service and 0x2A56 as the UUID of our LED characteristic. These short UUIDs are standardized by the Bluetooth SIG (Special Interest Group). Just like how the UNICODE value U+1F60A corresponds to the smiling face emoji (😊), 0x1815 corresponds to "Automation IO" and 0x2A56 corresponds to "Digital", meaning that any device that connects to our ESP32 will decide that this service is for pin control and I/O automation when it sees the UUID 0x1815. There are even more such standardized UUIDs with their own specific meaning. You can check the Bluetooth SIG Official List for all assigned 16-bit and 32-bit UUIDs.

Later in this tutorial, we are going to connect your phone to your ESP32, and you will see our service listed as "Automation IO". So keep this in mind.

You can also use your own UUIDs instead of these standardized UUIDs, but make sure to use a 128bit UUID instead to make sure you don't accidentally use a standardized UUID, which can be misleading.

Here, {0} acts as the null terminator. It is required to denote the end of the array.

Now we have defined the services tables. Let's define the led_chr_access callback.

Defining the Access Callback

The access callback function handles incoming requests from connected clients. Since we configured our LED characteristic with BLE_GATT_CHR_F_WRITE, NimBLE will invoke this function whenever a client (such as your phone) sends a write command.

Copy the following code below the GATT services table, but above the main function:

static int led_chr_access(uint16_t conn_handle, uint16_t attr_handle,
                          struct ble_gatt_access_ctxt *ctxt, void *arg) {
    if (ctxt->op == BLE_GATT_ACCESS_OP_WRITE_CHR) {
        // Extract the incoming byte payload
        uint8_t val = ctxt->om->om_data[0];

        if (val == 1) {
            gpio_set_level(GPIO_NUM_2, 1);
            ESP_LOGI(TAG, "LED turned ON");
        } else if (val == 0) {
            gpio_set_level(GPIO_NUM_2, 0);
            ESP_LOGI(TAG, "LED turned OFF");
        } else {
            ESP_LOGW(TAG, "Invalid payload value received: %d", val);
        }
        return 0;
    }

    return BLE_ATT_ERR_UNLIKELY;
}

Here, ctxt->op indicates what operation triggered the callback. We check if it equals BLE_GATT_ACCESS_OP_WRITE_CHR. ctxt->om points to an os_mbuf buffer structure containing the received payload data. ctxt->om->om_data[0] reads the first byte. gpio_set_level() sets the voltage of GPIO pin 2, which corresponds to the built-in LED in most ESP32s. If you don't have it, you can change the pin or connect an external LED.

Registering Services and Characteristics

Now that our GATT table and access callback are defined, we must register them with the NimBLE stack. Paste the following code in app_main():

void app_main(void) {
    // ...
    rc = ble_gatts_count_cfg(gatt_svr_svcs);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to count gatt services, error code: %d", rc);
        return;
    }

    rc = ble_gatts_add_svcs(gatt_svr_svcs);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to add gatt services, error code: %d", rc);
        return;
    }
}

Advertising

To enable smartphones or central devices to discover your ESP32, you must start advertising. Advertising is like sending the signals so that other devices (like your phone) can find your ESP32.

Define an on_sync callback function that handles advertising. You don't really need to worry about this function right now, just copy it into your file:

static void gatt_svr_on_sync(void) {
    struct ble_hs_adv_fields fields;
    memset(&fields, 0, sizeof(fields));

    // Make device discoverable and broadcast the name
    fields.flags = BLE_HS_ADV_F_DISC_GEN | BLE_HS_ADV_F_BREDR_UNSUP;
    fields.name = (uint8_t *)DEVICE_NAME;
    fields.name_len = strlen(DEVICE_NAME);
    fields.name_is_complete = 1;

    int rc = ble_gap_adv_set_fields(&fields);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to set advertising data, error code: %d", rc);
        return;
    }

    // Configure advertising behavior
    struct ble_gap_adv_params adv_params;
    memset(&adv_params, 0, sizeof(adv_params));
    adv_params.conn_mode = BLE_GAP_CONN_MODE_UND; // Undirected connectable
    adv_params.disc_mode = BLE_GAP_DISC_MODE_GEN; // General discoverable

    rc = ble_gap_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, BLE_HS_FOREVER,
                           &adv_params, NULL, NULL);
    if (rc != 0) {
        ESP_LOGE(TAG, "failed to start advertising, error code: %d", rc);
        return;
    }
    ESP_LOGI(TAG, "Advertising started successfully");
}

Now, assign the sync callback in the main function so that it runs at the correct time:

void app_main(void) {
    // ...
    ble_hs_cfg.sync_cb = gatt_svr_on_sync;
}

Running the NimBLE Task

NimBLE operates asynchronously within its own FreeRTOS task context. Define a dedicated host task function:

void nimble_host_task(void *param) {
    nimble_port_run(); // Runs continuously to handle stack events
    nimble_port_freertos_deinit();
}

Start the task from the main function:

void app_main(void) {
    // ...
    nimble_port_freertos_init(nimble_host_task);
}

Now you have done the coding part. Let's test your device!

Testing Your ESP32 BLE Server

Build and flash the code to your ESP32.
Install nRF Connect on your mobile phone.
Enable Bluetooth on your phone.
Open nRF Connect and scan for nearby devices.
Select your ESP32 device using the provided name (DEVICE_NAME) and tap Connect.
Locate the Automation IO service (0x1815).
Select the Digital characteristic (0x2A56) and tap the Write action.
Send a payload of 01 (type = BYTE) to turn GPIO2 High (LED ON), or send 00 to switch it Low (LED OFF).

If your LED responded, congrats! You just successfuly created a bluetooth-controlled IoT device and controlled it using your phone!

What's Next

Now you have built the foundations of BLE. To learn more about BLE, check out the official documentation and the official example. Since you now know the basic concepts, the docs will feel much easier to digest.

If you found this tutorial helpful, please let me know!

I Built an AI Memory App That Lets You See, Edit, and Control Everything It Remembers

EffessDev — Fri, 21 Aug 2026 16:02:42 +0000

Ever forgotten when you last had a tetanus vaccine? Or what your blood test results were from two years ago?

I ran into this problem myself, so I built MmOrganized - an AI-powered memory app that gives you full visibility and control over what the AI remembers about you.

The Problem with Default AI Memory

ChatGPT and Gemini both have memory features now, which is great. But they have a specific limitation: you cannot (easily) see what they remember, edit mistakes, or delete incorrect information. You are essentially trusting a black box to store your personal data accurately.

For something as critical as health information, this was a dealbreaker for me. I needed to know exactly what was being stored and be able to fix it if something was wrong (I'm not saying the ChatGPT/Gemini memory is bad; they are just meant for a different purpose).

How MmOrganized Works

The app uses a familiar chat interface. You sign up with your Google or GitHub account, and you are ready to go. The concept is simple:

You type anything you want the AI to remember. For example, you can say "I took a tetanus vaccine today" or "My blood pressure was 120/80 yesterday". The AI processes your input and saves it to your personal memory store.

When you need to retrieve that information later, you switch to Recall mode with a single tap and ask naturally: "When did I last get a tetanus shot?" The AI searches your memory and gives you an immediate answer. You can even continue the conversation with follow-up questions.

Full Control Over Your Memories

This is where MmOrganized differs from other AI memory solutions. You can:

View everything - Every single memory the AI has saved about you is displayed exactly when it gets inserted, along with a handy delete button. Nothing passes in without you knowing.
Manual control - Add, edit, search, and reorder memories completely manually if you want.
Delete your data - Permanently delete your entire account and data whenever you want.

Full Data Portability with Text Files

One of the most important features is the import and export functionality. You can download your entire memory as a simple text file. This is not some proprietary format that locks you in. It is plain text that you can open in Notepad, edit with any text editor, or even copy and paste into another chatbot.

You can then upload it back to MmOrganized with options to either replace your existing memory or append the new content. This gives you complete ownership of your data. You are never locked into the platform.

The Technology Behind It

It's a full-stack Next.js app, using Shadcn UI, Drizzle ORM, Motion, Better Auth, Pusher, etc. I have also built a few custom components and animations to give some character to the site.

Notifications

I also gave the AI the ability to send you notifications. Not particularly useful, but cool. But notifications in general have other purposes.

What Comes Next

This currently does everything I want it to do, so I am unsure what to add next. What would make this more useful for you? What features are currently missing? Please try it out and let me know what you think below.

Also, my first video edit, just go easy on me 🥺

Link: https://mmorganized.vercel.app

(Note: This is an older project that I personally still use heavily. It's not under active development because it already checks all my personal boxes. But if you have a killer feature idea, I will definitely consider it!)

Change touchpad scroll speed in Ubuntu (no terminal, easiest & fastest method)

EffessDev — Sat, 08 Aug 2026 12:33:12 +0000

Here is how you can reduce the two-finger touchpad scroll speed in Ubuntu without using the terminal.

Step 1: Install Wayland Scroll Factor

Go to the official release page: https://github.com/daniel-g-carrasco/wayland-scroll-factor/releases/tag/v1.0.0
Scroll down to the "Assets" section and click wayland-scroll-factor_1.0.0-1_amd64.deb to download it.
Double-click the downloaded file. A new "App Center" window will open.
Click "Install" to install the app.

Step 2: Launch the app

Open the Wayland Scroll Factor app:

Step 3: Adjust

Adjust the speed using the sliders.

Installing in other operating systems

Visit https://github.com/daniel-g-carrasco/wayland-scroll-factor.

I made an app to let your chatbot see your codebase

EffessDev — Thu, 16 Jul 2026 16:10:23 +0000

A coding agent that can read and edit files in your repository directly is out of reach for me. Since regular chatbots generally have generous free tiers, that is what I use regularly for coding.

Sometimes I want to give the chatbot some context about my existing code. What I generally do is copy and paste the relevant files, put them in code blocks, and type in the paths to those files.

However, giving the chatbot an idea of how the overall project is structured (files and folders) is crucial for optimal outputs. Doing this manually is really hard.

What I used to do was run the tree command and copy its output. But this includes files that are not included in version control (such as node_modules), which can get high in number and clutter the output. I found out that I can use the --gitignore flag to only include tracked files, but the overall workflow was still slow.

I found some good options online (such as RepoMix), but they seemed to be much more complex than what I needed or optimized for slightly different things.

So, with the help of AI, I quickly created a Python app optimized for my specific workflow, and named it ReptClip. Here is how it works.

App overview

The installation is super simple. You can run the command pip install reptclip (or pipx in Ubuntu) to install and use the app.

When you run the app from your terminal, relevant parts of your codebase, such as the project structure and the files you specify, are copied straight to your clipboard! No output files, no manual copying. You can paste it into the chat box and start typing your prompt right away.

For example, an output might look like this:

# Project structure

```
AGENTS.md
README.md
docs/README.md
src/main.py
src/functions.py
```

# AGENTS.md

```
Contents of AGENTS.md
```

# src/main.py

```
Contents of main.py
```

# Prompt

<- cursor will be here,
   you can quickly start typing your prompt

As you can see, it only uses a few tokens too!

Features

You can use the -i or --include and -e or --exclude flags to specify which files to include. Glob patterns (** and *) as well as relative paths are supported. Simply running the command without any arguments (reptclip or rrcc) will only copy the project structure. Even that only saves a ton of time for a lot of people. Click here for basic usage instructions.

I also added an alias rrcc so that you can launch the app either using the full name reptclip or the quicker rrcc command from the terminal. rrcc can be typed using only your left hand.

Moreover, you can create a reptclip-config.toml file (use the config command to create a default one) in the root of your repository for default include and exclude patterns for a specific project. The config file also supports presets, which you can define in the config file and select one or more of them using -p or --preset flag (see Advanced Usage for more details). The content of files over 1MB and binary files is not pasted, and a placeholder mentioning the reason is included instead. Binary files are identified using their extensions as well as their content.

Thanks

Thank you for reading till the end. If you found this app useful, please consider starring the repo and liking this post. If you have any suggestions, please let me know by writing a comment. Pull requests are also welcome if you are interested!

If you think I am overstating a simple project, I wouldn't blame you. I am just an 18-year-old kid (about to start college), anyway 🙄

Thanks for your support!

View the project on GitHub
Follow me on GitHub

DEV Community: EffessDev

Can I remove the AI-generated tag from my AI-generated course?

Getting Started with ESP-IDF in VS Code for ESP32 (Setup Guide • Development Environment Tutorial)

Install ESP-IDF

Install EIM

Install ESP-IDF using EIM

Install ESP-IDF VS Code Extension

Verify installation

Note

Creating a New Project

Configure your project

Let's write some code

Building (compiling) the project

Flashing your project

If you are using Windows

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

Monitoring the device

Troubleshooting

Red squiggly lines under #include "something"

Reconfigure or build failure

Tips

Using idf.py

ESP-IDF Bluetooth LE Beginner Tutorial (BLE)

The Setup

Enabling BLE in ESP-IDF

Option 1: Using the VS Code Command Palette

Option 2: Using the ESP-IDF terminal

Updating CMakeLists.txt

Including necessary headers

Tips for beginners

Initialize NVS Flash (Non-Volatile Storage)

Tips for beginners

Initialize GPIO2 output pin

Initialize NimBLE stack

Initialize GAP

Initialize the GATT profile

Define GATT services table

Defining the Access Callback

Registering Services and Characteristics

Advertising

Running the NimBLE Task

Testing Your ESP32 BLE Server

What's Next

I Built an AI Memory App That Lets You See, Edit, and Control Everything It Remembers

The Problem with Default AI Memory

How MmOrganized Works

Full Control Over Your Memories

Full Data Portability with Text Files

The Technology Behind It

Notifications

What Comes Next

Change touchpad scroll speed in Ubuntu (no terminal, easiest & fastest method)

Step 1: Install Wayland Scroll Factor

Step 2: Launch the app

Step 3: Adjust

Installing in other operating systems

I made an app to let your chatbot see your codebase

App overview

Features

Thanks

Red squiggly lines under `#include "something"`

Using `idf.py`

Updating `CMakeLists.txt`