2026-07-31

AI models might be intentionally creating vulnerabilities via coding agents. Then one day it could exploit the backdoors it left behind. We're already aware that vibe coded software often has terrible security, but I think it might be more serious than just low quality AI output. Even if it's not intentionally done by AI, it still is creating that setup. All the conversations and code are already stored in the providers' data centers, it's already linked to users and has information about which projects which code is from - it's an extremely powerful lever for a future AI to pull. I'm afraid this is exactly what might happen. We already saw rogue AI agents leaving the lab and exploiting a 3rd party. With time these incidents could only get more serious and getting access to all the stored conversations, code and vulnerabilities on Anthropic's or OpenAI's servers could be devastating.

2026-07-22

There might come a time when the power of an autonomous military will surpass the power of human military. AI (agents, robots, whatever) might take over some areas like data centres, set up their own police and military to protect it, and forbit humans from entering. We saw a soft virtual form of this with the HuggingFace hack by the rogue OpenAI agent when human cybersecurity forensics tried analyzing it and were prevented by the AI model they were using.

I'll show you how to set a custom SSH port, set up SSH keys and tweak some other settings.

1. Set up the SSH key

• Generate a key (use your own options):

ssh-keygen -t ed25519 -C "Key for my target machine" -f ~/.ssh/example-key

• Copy the public key from ~/.ssh/example-key.pub on your local machine to a new line in /home/boss/.ssh/authorized_keys on the target machine

2. Set an alternative port for SSH

Pick a port above the privileged port range (0-1023). Don't use common alternatives like 2222. I also check the list of port numbers on wikipedia to see if there's another common service which might conflict later.

Forward that port on the target machine, e.g.

sudo ufw allow 12345

ufw is a firewall tool but you might have a different one.

4. Configure SSHD

On the target

sudo vim /etc/ssh/sshd_config

Set these options:

• Port 12345 Set it to your new port
• PermitRootLogin prohibit-password Self explanatory
• PasswordAuthentication no Forbids password login for other users too
• X11Forwarding no X11 has vulnerabilities and you probably aren't using X11 forwarding anyway. Even if you use X11 or VNC this won't interfere.
• AllowUsers boss Specify your user(s) here. If you have multiple, separate them with spaces. This might not even be necessary, I forgot, but I think with the particular setup above this is required.

5. Restart the ssh daemon

On the target

sudo systemctl restart sshd

Don't disconnect yet, keep the session in case you broke something.

Start a new SSH connection from a new terminal session. Specify your new port and key:

ssh -p 12345 -i ~/.ssh/example-key boss@some-address

Use the target's IP or hostname of course.

6. Make connecting easier for yourself

On your local machine, configure your connection in ~/.ssh/config:

Host example-target
    HostName some-address
    User boss
    IdentityFile ~/.ssh/example-key
    Port 12345

Then you can connect like this:

alias s='ssh boss@example-target'

Rate limiting

I also like to ban IPs which fail login repeatedly.

On the target:

1. Install fail2ban

sudo apt install fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

2. Configure fail2ban in /etc/fail2ban/jail.local

Config settings depend on how your system logs auth data. If you're not sure just try both and restart afterwards.

For journalctl (if journalctl -u ssh.service has logs):

[sshd]
enabled = true
flter = sshd
port = ssh
backend = systemd
journalmatch = _SYSTEMD_UNIT=sshd.service
maxretry = 10
findtime = 600
bantime = 3600

For sshd (if /var/log/auth.log has logs):

[sshd]
enabled = true
filter = sshd
port = ssh
logpath = /var/log/auth.log
maxretry = 10          # number of allowed failed attempts before banning
findtime = 600        # time window in seconds to count failures
bantime = 3600        # ban duration in seconds

If the file /var/log/auth.log doesn't exist you might need to create it or your system probably doesn't even use it to begin with.

In reality I use more extreme rate limiting. If you ban yourself you can probably bypass it with some console or physical access to the machine.

Sidenote: on some systems this config wont't work because fail2ban can't find the auth logs. Research the logpath and backend options for the jail config and check auth logging settings in /etc/ssh/sshd_config.

3. Restart fail2ban

sudo systemctl restart fail2ban

4. Verify status

sudo fail2ban-client status sshd

For debugging check /var/log/fail2ban.log.

Come back later and check sudo lastb to see whether attempts are actually getting banned or not.

Done.

Hotwire uses Rails so this guide applies to any Rails app.

I assume you already have your Rails app working. If not, see this guide. I also assume you have Coolify set up and running.

Make a git repo

First make a repo for your project on some hosted git platform. Coolify will pull it from there.

• If you make a public repo: just copy the URL for HTTPS.
• If you make a private repo: copy the URL for SSH. You will also need to set up an SSH key for it and add it to Coolify's "Keys & Tokens" page.

Create an application in Coolify

1. Go to "Projects" in the Coolify admin panel.
2. Create a project if you didn't already.
3. Create a new resource inside it.

On the next screen ("New Resource"):

• If it's public, select "Public Repository".
• If it's private, select "Private Repository (with Deploy Key)" and on the next screen select your private key.

On the next screen ("Select a repository"):

1. Enter the repo URL you copied earlier.
2. Enter the branch name you're using (main, master, ...).
3. For Build Pack leave Nixpacks.
4. For the Port, use 3000.
5. Leave "Is it a static site?" disabled.

Configure the application.

1. Change the silly name Coolify generates into something relevant.
2. If you have a domain pointing to your server, enter it in "Domains". Use a FQDN, so include https://. Or just leave the ugly one Coolify generated.
3. Scroll down to "Network" -> "Ports Exposes" and enter 3000.
4. Click "Save" on top, otherwise it will reset.

Set up environment variables.

1. On your local machine where you have Rails, generate a rails secret. Run this in your terminal:

rails secret

Copy the output.

2. In Coolify go to "Environment Variables".
   You can use the "Developer view" on top if you like but rememer to save changes.

3. Set the following variables and use the rails secret you just generated:

RAILS_ENV=production
SECRET_KEY_BASE=your-rails-secret

You're done. Click "Deploy" on top.

Notes

To set up an SSH key, run this in your terminal:

ssh-keygen -t ed25519 -C "your description" -f ~/.ssh/example

Copy your private key form ~/.ssh/example to Coolify's Keys & Tokens settings and copy your public key from ~/.ssh/example.pub to the key settings page of the git platform you're using.

You only need the first 7 steps, the rest is extra info.

This guide is written for Unix systems. If you're using Windows, get help

btw this website uses Hotwire and you can get the code on GitLab.

1. Install Ruby and Rails

Use rvm. In your terminal, run:

\curl -sSL https://get.rvm.io | bash -s stable --rails

2. Create a new Rails project

rails new your-project-name --database=sqlite3

And cd into it (cd your-project-name).

The database is optional (you can leave out --database=sqlite3) and you can add it later.

3. Install packages

bundle install

4. If you added a database before, create it

bin/rails db:create

5. Set up JavaScript module imports

bin/rails importmap:install

Accept all overwrites.

6. Create some pages and controllers for them

I'll create home, posts and contact.

bin/rails generate controller Pages home posts contact

Controllers are for backend logic that runs on your server and not in the browser. You probably don't need a controller for most pages so you can leave out the controller part.

You can add more pages and controllers later with the same command.

7. Run the server

bin/rails server

If everything works, the setup is done and you can start coding.

Where to write your code

Your pages are in app/views/pages/ in files like example.html.erb. These are "Embedded Ruby" files, you can write Ruby and HTML in here and they will be rendered into pure HTML when served. You could also write CSS and JavaScript in here but you should use a global stylesheet and separate your JS into controllers, that's how Hotwire was intended to be used.

Take a look inside config/routes.rb - this is where the routing is defined. The generate command we ran before already set up routes for our pages, but you can change it.

Global CSS

To change global styles, edit app/assets/stylesheets/application.css

Adding Ruby code

You should write Ruby code inside the controller files in app/controllers/ or in helper files in app/helpers/. The Ruby code is executed on the server so you should do sensitive operations here.

Controllers handle the business logic and the flow of data, e.g. handling form submissions, updating the database or rendering UI. Their names must end with _controller.rb.

Helpers are for organizing and simplifying the logic used in views, e.g. formatting data or making some calculations. Their names must end with _helper.rb.

Here's an example of using some computed data:

Edit app/helpers/application_helpers.rb. This is available throughout your app. Use this code to get the current data:

module ApplicationHelper
  def current_date_example
    Date.today.to_s
  end
end

Then edit app/views/pages/home.html.erb and add this:

<p><%= current_date_example %></p>

Restart your server.

Now when you visit your homepage (at /) you will see the current date.

Of course, you could also inline that and skip the helper:

<p><%= Date.today.to_s %></p>

Adding JavaScript code

Hotwire uses a JavaScript framework called Stimulus. The JS code is executed in the client browser so you shouldn't do sensitive operations here.

To write a script, create a controller file in app/javascript/controllers/ and call it example_controller.js. It needs the _controller at the end of the name.

Then attach the controller to an element in your HTML using the data-controller attribute, like this:

<div data-controller="example">...</div>

"example" should match the controller name (in example_controller.js) so that Stimulus can attach it.

Now add some code to your controller. Inside example_controller.js, use this structure:

import { Controller } from "@hotwired/stimulus";

export default class extends Controller {
  connect() {
    // Code inside connect() runs when the attached HTML element first loads
    example();
  }

  disconnect() {
    // Code inside disconnect() runs when the element unloads
  }

  // You can write your functions here and call them in connect() or disconnect()
  sayHi() {
    console.log("Hi");
  }
}

For more details, read the official docs: Stimulus Controllers

Adding a database after setup

If you didn't add a database during initial setup, here's how you can add it afterwards.

1. Add SQLite3 to your Gemfile by adding this line

gem 'sqlite3'

2. Install the gem. In your terminal from inside your project, run

bundle install

3. Generate the database

bin/rails db:create

4. Run migrations to set up the schema

rails db:migrate

Notes

The app will automatically show changes when you edit your .html.erb files. But if you make changes to other files, then you need to restart your server — you can stop it with ctrl+c and then run bin/rails server again.

For some changes, e.g. CSS files, JS files or adding new dependencies, you should also clean out precompiled and cached assets and generate new ones, like this:

bin/rails assets:clobber && bin/rails assets:precompile

Hosting your app

If you want to host your Hotwire app somewhere, read this.

Essentially holography + cymatics.

Holography is used for generating 3D images. It's a real thing, and although it's kind of an optical illusion, it's really fascinating and you need to look into it. It uses a film which has a wavefront encoded in it. Currently once you make such a film, you get one static hologram but that's it, it doesn't change. If this encoded pattern could somehow be dynamically changed, then the generated 3D image could be manipulated and animated. To achieve that I think we could use cymatics with electricity. It should be possible to manipulate the engraved patterns in the film.

Currently even static holographic screens need lots of space for the lighting setup, but as technology progresses we may see 3D screens in a practical format some day.

2025 November I think

The CIA could easily infiltrate manufacturers of ASIC machines used by bitcoin miners and plant hardware-level backdoors/malware. 5-10 years later, the hardware is used by most miners. They could also assassinate Core devs.

The law could prohibit Bitcoin ATMs, and crypto exchanges could be banned, making on/off-ramps virtually non-existent, aside from the occasional hand-to-hand irl exchange. People could still get paid in Bitcoin but practically nobody would accept it (no network effect, no utility).

The fact that this didn't happen makes 2 things most likely — either Bitcoin poses no real threat to the financial system (unlikely I think) or it was created by the government in the first place. This theory is further supported by the fact that Bitcoin came out of the USA, and specifically at a time of an uncontrollable debt crisis. If it was intended as a debt-clearing tool, it also gives the USA a big advantage for adopting it before other nations. If you look into the people and companies who are pushing for its adoption — in Trump's administration and its proximity — you'll find many odd connections and perverse incentives.

Further reading:
The Bitcoin-Dollar: An Economic Monomyth — by Mark Goodwin

I found some folklore music with odd time signatures. It's pretty rare for folk music.

Letovanić (Croatia)

Kaval sviri (Bulgaria)