Is AI really underperforming, or are we not communicating our requests effectively?

In the age of artificial intelligence, Large Language Models (LLMs) like Claude and GPT have become indispensable tools for businesses and individuals alike. They assist with everything from drafting emails to generating complex reports. Yet, a common frustration persists: "The AI isn't giving me the results I want."

I've noticed a recurring pattern when discussing AI capabilities. Many express dissatisfaction with the outputs they receive. However, when I delve deeper and ask them to articulate what they were trying to achieve, their explanations are often vague, confusing, or even unintelligible. This isn't a reflection of their intelligence or expertise; rather, it highlights a fundamental challenge in human communication.

The Human Communication Gap

Effective communication is a skill that even the most seasoned professionals continually refine. We might have a clear idea in our minds, but translating that into words—especially in a way that an AI can understand—is another matter entirely. If our peers sometimes struggle to grasp our intentions, it's reasonable to expect that an AI, which relies strictly on the input it receives, might also struggle.

Why Prompts Matter

LLMs are designed to process and generate text based on the input they receive. They don't infer intent beyond what's provided. Therefore, the specificity and clarity of your prompt directly influence the quality of the AI's output.

For example:

• Vague Prompt: "Write about marketing."
• Clear Prompt: "Compose a 500-word article on the impact of social media marketing on consumer purchasing behavior in the fashion industry."

The second prompt provides context, scope, and specific details that guide the AI to produce a more targeted and valuable response.

Bridging the Gap

To harness the full potential of AI, we need to become better at communicating our ideas:

1. Be Specific: Clearly state what you want. Include details like length, format, style, and key points to cover.
2. Provide Context: Explain the purpose of the output. Is it for a technical audience, a casual blog, or a formal report?
3. Use Simple Language: Avoid ambiguous terms and jargon unless necessary. If you use specialized terminology, ensure it's correctly defined.
4. Iterate and Refine: If the output isn't what you expected, adjust your prompt. Consider what might have been misunderstood and clarify.

Embracing Responsibility

It's easy to blame the tool when we don't get the desired results. However, AI models are reflections of the input they receive. By taking responsibility for how we communicate with them, we not only get better results but also enhance our own communication skills—a benefit that extends beyond interacting with AI.

Conclusion

LLMs are powerful allies in productivity and creativity, but like any tool, they require skill to use effectively. By focusing on how we craft our prompts and communicate our ideas, we can unlock their full potential and achieve outcomes that meet or even exceed our expectations.

Let's turn the mirror inward and consider how we can improve our interactions with AI. After all, clear communication isn't just essential for AI—it's a cornerstone of all successful human endeavors.

There are many options for creating backups. Some solutions have extensive user interfaces or features such as encryption, compression, deduplication and block level incremental backup. A nice open source example of this is Duplicati.

I chose a simple setup with Rclone because it fits my needs well. Rclone can synchronize files from your computer to any of the common cloud storage providers. It can also perform two way synchronization, allowing you to mirror folders across computers. There are many more features listed on the website.

For storage, Backblaze B2 is reliable and secure while still being cheap. Anything under 10GB is free, and 100GB costs 50 cents per month. B2 has a native ability to keep old versions of files, and the retention policy for old versions is highly configurable.

You can turn on transparent encryption in the bucket settings.

The third piece of the puzzle is a way to run Rclone on a schedule. There are two great options for this, cron jobs and systemd timers. A systemd timer is a more modern solution that can be configured to run periodically based on the time that the last backup job finished.

These services make setup and usage simple while still having all the features I want:

• Reliability
• Security
• Automation
• Low cost
• Ability to browse backup files from any phone or computer

Setup Instructions

First, install Rclone. It can be found in most package managers. Then you'll have to configure your remote. If you choose Backblaze B2, create a bucket and generate a new application key to use with Rclone. Add the remote with rclone config.

Next, create a backup script that runs Rclone and specifies the folders you want to back up. I placed my script at /usr/local/bin/rclone-backup.sh

#!/bin/bash

if [[ "`pidof -x $(basename $0) -o %PPID`" ]]; then
    echo "rclone-backup.sh is already running"
    exit;
fi

rclone sync -v --fast-list --transfers 30 /home/jeremiah/Documents/ b2:backup-bucket-name/Documents/

rclone sync -v --fast-list --transfers 30 --exclude node_modules/ --exclude .git/ /home/jeremiah/Projects/ b2:backup-bucket-name/Projects/

Give the script executable permissions with chmod +x. Don't forget to test your script when you think it's ready.

Finally, you'll need to set up systemd. Create a systemd service file at /etc/systemd/system/rclone.service

[Unit]
Description=RClone Backup

[Service]
Type=simple
ExecStart=/usr/local/bin/rclone-backup.sh

Then create a timer at /etc/systemd/system/rclone.timer. Further documentation can be found here.

[Unit]
Description=RClone Backup Timer

[Timer]
Unit=rclone.service
# Run 15 minutes after boot, since the timer must run at least once
# before OnUnitInactiveSec will trigger
OnBootSec=15m
# Run 15 minutes after rclone.service last finished
OnUnitInactiveSec=15m
# Run once when the timer is first started
OnActiveSec=1s

[Install]
WantedBy=timers.target

After saving these files, you may need to run:
sudo systemctl daemon-reload

Make the timer start on boot by enabling the timer:
sudo systemctl enable rclone.timer

Start the timer now with:
sudo systemctl start rclone.timer

The backup script should run once and the timer will trigger it again in 15 minutes. You can check the timer status with:
sudo systemctl status rclone.timer

rclone.timer - RClone Backup Timer
 Loaded: loaded (/etc/systemd/system/rclone.timer;
    enabled; vendor preset: disabled)
 Active: active (waiting)
    since Wed 2021-06-16 12:00:24 PDT; 1h 41min ago
 Trigger: Wed 2021-06-16 13:56:10 PDT; 14min left
 Triggers: rclone.service

systemd[1]: Started RClone Backup Timer.

You can also check the status of the service with:
sudo systemctl status rclone.service

rclone.service - RClone Backup
 Loaded: loaded (/etc/systemd/system/rclone.service; static)
 Active: inactive (dead)
    since Wed 2021-06-16 13:41:10 PDT; 6min ago
 TriggeredBy: rclone.timer
 Process: 51857 ExecStart=/usr/local/bin/rclone-backup.sh
    (code=exited, status=0/SUCCESS)
 Main PID: 51857 (code=exited, status=0/SUCCESS)
 CPU: 1.248s

rclone-backup.sh[51917]: INFO: There was nothing to transfer
rclone-backup.sh[51917]: Checks: 476 / 476, 100%
systemd[1]: rclone.service: Deactivated successfully.
systemd[1]: rclone.service: Consumed 1.248s CPU time

If you want to manually run a backup at any time, just start the service manually:
sudo systemctl start rclone.service

Websites often have content that rarely changes. Cloudflare offers a free service that hosts your content on 200+ servers around the world. As content changes, the cached copies are invalidated and fetched from the origin server. In this way, a website can handle millions of requests at high speed with a single core origin server.

There are a few Cloudflare page rules that enable caching of an entire website. The first rule is an exception that allows the admin area to be accessed properly. The second rule tells Cloudflare to cache everything on the edge servers for 30 days.

Let's say content changes on the website, for example a new blog post is published. There's an easy way to let Cloudflare know so all the edge servers get a new copy of the changed pages. Using the Purge Files by URL API method it's possible to tell Cloudflare to expire the cache for a single URL or multiple URLs. Each page on the website is slightly slower on the first page load but the page will be cached from then on. In the case of a blog post, the homepage URL, author URL and tag URLs would need to be purged. Depending on your web stack it might be straightforward to implement. On Ghost blogging software it can be done using multiple webhooks such as post.added, Ghost will send all the URLs you need in the request. If you want to easily inspect what is sent to the webhook endpoint I recommend https://webhook.site/.

For the sake of simplicity I used the Purge All Files method. My website is small enough and the server can handle the load, so it doesn't really matter if the entire cache is purged. I created a webhook in Ghost that fires when anything on the site changes, this particular webhook does not send any data about what changed. For the webhook endpoint I set up a simple Cloudflare worker which is included in the free plan. When the webhook fires, the worker gets a request and then sends a request to the Cloudflare API. Here's the Cloudflare worker code I used based off of the code I found here:

addEventListener('fetch', event => {

    event.respondWith(purgeCache(event.request))

})

async function purgeCache(request) {

    const url = new URL(request.url)
    const zone = url.searchParams.get('zone')
    
    let zoneIdValidated = (new RegExp("^([a-z0-9]{32})$")).test(zone)
    let keyValidated = (new RegExp("^SECRET_KEY$")).test(url.searchParams.get('key'))

    if (!keyValidated) {
        return new Response('Invalid auth', {
          status: 500
        })
    }

    if (!zoneIdValidated) {
        return new Response('Invalid Zone ID', {
          status: 500
        })
    }

    const data = {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': 'Bearer CLOUDFLARE_API_TOKEN_WITH_PURGE_PERMISSION'
        },
        body: '{"purge_everything":true}'
    }
    
    const response = await fetch(
        'https://api.cloudflare.com/client/v4/zones/' + zone + '/purge_cache',
        data
    )

    return response
}

The webhook endpoint will look like this: https://workername.yoursubdomain.workers.dev/?key=SECRET_KEY&zone=CLOUDFLARE_ZONE

You'll have to create a new integration in the Ghost admin area:

Propagation should take around 10 seconds after site content changes.

Final Thoughts

• It would be interesting to implement a Ghost plugin that communicates directly with the Cloudflare API and purges all the relevant URLs.
• Ghost is open source and the "Site changed" webhook could be updated so it sends data about what changed. Then the Cloudflare worker could identify what needs to be purged.
• Any updates to CSS or JavaScript files will require a manual purge, a separate server process that watches for file changes could trigger the Cloudflare worker to purge the cache or call the API method directly. It wouldn't be too hard to implement in Node, and Ghost is already running on Node.

The west coast fires of September 2020 produced massive amounts of smoke and air pollution rose to dangerous levels. I stumbled upon the PurpleAir PA-II air quality sensor which was providing much of the state-wide air quality data. Internally it uses a PMS5003 and I picked one up for $20 on eBay.

The goal of this project was to create a internet connected air quality sensor that records data in real time. This sensor was also used to test the effectiveness of a cheap non-HEPA filter and a true HEPA filter. The cheap filter appeared to work quite well for this type of pollution.

The sensor can detect particles down to 0.3 microns, it sends data over serial. Some models support I2C as well. There are many libraries that can translate the binary data, I ended up using Adafruit_PM25AQI. I used only PM1.0 and PM2.5 data since PM10 seems to be extrapolated from PM2.5 on this device.

The sensor is connected to an ESP32 which sends data over Wi-Fi to a cloud server running node and MySQL. As data is received the node app records timestamped data into a database. Node can update graphs in real time using a WebSocket connection to a browser. Historical data can been viewed as well.

The code for the ESP32 is simple, every 5 seconds data is read and data is sent to the node endpoint. A key is used to prevent false data and identify the device.

#include "Adafruit_PM25AQI.h"
#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "SSID";
const char* password = "PASSWORD";

Adafruit_PM25AQI aqi = Adafruit_PM25AQI();

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10);
  delay(1000);
  WiFi.begin(ssid, password);
  Serial.println("Connecting to wifi");
  while(WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
  Serial.print("Connected to WiFi, IP Address: ");
  Serial.println(WiFi.localIP());

  Serial2.begin(9600);

  if (!aqi.begin_UART(&Serial2)) {
    Serial.println("Could not find PM 2.5 sensor");
  }
}

void loop() {
  PM25_AQI_Data data;
  if (! aqi.read(&data)) {
    delay(500);
    return;
  }
  if(WiFi.status() == WL_CONNECTED){
    HTTPClient http;
    http.begin("https://example.com/aqi/sendData");
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");
    String httpRequestData = "key=gj29xh3ngfw32pz84ns"
    + "&pm1=" + String(data.pm10_env)
    + "&pm25=" + String(data.pm25_env);
    int httpResponseCode = http.POST(httpRequestData);
    Serial.print("HTTP Response code: ");
    Serial.println(httpResponseCode);
    http.end();
  }
  else {
    Serial.println("WiFi Disconnected");
  }

  delay(5000);
}

To be continued