nateberkopec

Protecting Against Autonomous Agent rm -rf Commands

Protecting Against Agent rm -rf Commands

AI coding agents can run shell commands. Sometimes they run rm -rf by mistake. This deletes files forever. While of course I always read and approve all tool calls manually, by hand, and never let my agents work except under direct supervision 100% of the time, sometimes I miss things.

How It Works

1. Hooks catch rm -rf before it runs
2. Refuse the command with a clear error telling you to use trash

stenuto

#!/bin/bash

# Function to display usage information
usage() {
    echo "Usage: $0 /path/to/input.mp4 [ /path/to/output_directory ]"
    exit 1
}

# Check if at least one argument (input file) is provided
if [ $# -lt 1 ]; then

rauschma

My writing process

Stages of my writing process

• Collecting material: For a number of topics that I may write about in the future, I have text files where I collect information as I come across it during coding, on the web, on Twitter, etc.

• Outline: The collected material is my starting point. I rearrange it into an outline which I refine until I’m happy with it. Refining includes adding/removing/rearranging items and doing more research when I notice gaps in my knowledge.

• Skeletal draft: I add bullet points and code examples until almost all of the content exists at least in skeletal form. This process often uncovers knowledge gaps and flaws in the structure of the content which I then can fix.

itsgoingd

#! /usr/bin/env ruby
# usage:
# $ das_download.rb email password
# based on various gists from this thread https://gist.github.com/maca/1798070

require "mechanize"
require "fileutils"

class DasDownloader
  attr_reader :agent, :email, :password

taxigy

;; without composition
(repeat 2 (apply * (map #(* 3 %) (map max [1 2] [4 5]))))

;; with composition
((comp (partial repeat 2)
       (partial apply *)
       (partial map (partial * 3)))
 (map max [1 2] [4 5]))

;; with thread macro

wrburgess

# app/jobs/example_job.rb

class ExampleJob < ActiveJob::Base
  queue_as :default

  rescue_from(ActiveRecord::RecordNotFound) do
    retry_job wait: 1.minute, queue: :default
  end

  def perform(param_1, param_2)

kares

require 'active_record/log_subscriber'

class SlowQueryLog < ActiveSupport::LogSubscriber

  if Rails.configuration.respond_to?(:slow_query_log_threshold_in_ms)
    if @@threshold = Rails.configuration.slow_query_log_threshold_in_ms
      @@threshold = @@threshold.to_i == 0 ? nil : @@threshold.to_i
    end
  else
    @@threshold = nil

pirj

You won’t find rants on how functional programming improves you, your sanity and your life overall here. There are some examples in the very beginning to save you some time on reading the whole post, just come along if you don’t like how they look like.

By the way, this is not even a blog, so formally this is not even a blog post. This is not a library or a new paradigm. It’s just a few pieces of code that might come handy for your daily job.

Example:

[1, 3.14, -4].map &_.safe{ magnitude odd? } # => [true, nil, false]

wvengen

Finding a Ruby memory leak using a time analysis

When developing a program in Ruby, you may sometimes encounter a memory leak. For a while now, Ruby has a facility to gather information about what objects are laying around: ObjectSpace.

There are several approaches one can take to debug a leak. This discusses a time-based approach, where a full memory dump is generated every, say, 5 minutes, during a time that the memory leak is showing up. Afterwards, one can look at all the objects, and find out which ones are staying around, causing the

RadhikaG

def parent(i):
    return i/2

def left(i):
    return 2*i

def right(i):
    return (2*i + 1)

class Heap: