👋 Hi, my name is Max Zsol.
I'm a computer engineer and writer of sci-fi,
some times with the help of AI.
I also blog about
writing,
mindfulness,
engineering leadership,
mechanical keyboards, and a long etcetera.
Getting Started with Love2D and VS Code: A Beginner’s Guide
“Love is life. All, everything that I understand, I understand only because I love.”
— Leo Tolstoy
What is Löve2D
For a few months now I have been playing with Pico-8, a flavor of Lua game programming, which provides a self-contained, minimal developer experience similar to the streamlined Löve2D setup (see Getting Started with Local Development for Pico-8 and VS Code if you want to know more.)
LÖVE is a framework build on top of Lua, used for making 2D games. It is free and open-sourced and focused on coding above all. Unlike more complex gaming frameworks like Unity, Unreal, and Godot, LÖVE is more bare-bones, requiring you to set up your own development environment. I am using VS Code for my projects, including Pico-8 and now for my VS Code configuration for Löve2D.
Here is all you need to get started building games with LÖVE and VS Code.
Setting Up Your Development Environment
Installing Löve2D
Visit https://love2d.org and download LOVE for your platform. For macOS download the corresponding zip file, unzip it, and move the file love.app to the Applications folder.
Double click the app and you should see a window with a welcome animation. (See “Issues and Troubleshooting” below if you run into problems on macOS)
Next you want to make LOVE accessible through the terminal. Start by creating an alias to the app via in your shell configuration file. I use Zsh so I need to edit ~/.zshrc.
You can open the file with VS Code in the command line via:
code ~/.zshrc
Add the following line to the file:
alias love="/Applications/love.app/Contents/MacOS/love"
You can now also open love by typing love in the terminal window. You might get a warning or an error stating LOVE “cannot load game”. This is expected and will address that next.
You can read detailed instructions here: https://love2d.org/wiki/Getting_Started
Creating Your First Löve2D Project
Create a folder for your project and create a file main.lua inside of it. Try this for starters as the content of this file:
function love.draw()
love.graphics.print("Hello World!")
end
Open terminal in your project folder from within VS Code (Terminal/New Terminal) and run your app by calling love with the project folder as an argument.
love .
This will instruct love to run the code inside the folder, starting by loading main.lua.
Congrats, your setup is done!
Configuring VS Code for Löve2D
VS Code can be best configured for workgin with Löve2D with the help of two extensions. Keyslam’s Appendix B: Setting up a minimal project yourself and Sheepolution’s Learn how to make games with LÖVE - VS Code were fantastic resources when looking at viable extensions.
Start by installing these extensions for VS Code:
You need to create a folder named .vscode in your workspace(the same location as your main.lua.). To configure these two extensions copy the following configuration inside the file:
{
"Lua.runtime.version": "LuaJIT",
"Lua.workspace.checkThirdParty": false,
"lua-local.interpreter": "LuaJIT"
}
Next, also inside your .vscode folder, and create a file named launch.json. Copy the following contents inside this file (See more information here:
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
"version": "0.2.0",
"configurations": [
{
"name": "Debug Love",
"type": "lua-local",
"request": "launch",
"program": {
"command": "love"
},
"args": [".", "debug"],
"scriptRoots": [".", "src"]
},
{
"name": "Release Love",
"type": "lua-local",
"request": "launch",
"program": {
"command": "love"
},
"args": ["."]
},
]
}
In my case I run into an error in the debug console:
/bin/sh: love: command not found
I was able to solve this by replacing
"command": "love"
with
"command": "/Applications/love.app/Contents/MacOS/love"
Running and Testing Your Project
My preferred way is to open the terminal within VS Code and simply type love .
Alternatively you can install Pixelbyte Studios’s VS Code extension Love2D Support, and use the shortcut Cmd+L to launch the project directly while editing your lua files.
Remember to set the path to love in the extensions settings. In my case /Applications/love.app/Contents/MacOS/love.
Debugging Your Löve2D Game
You will need to execute the following code in your main.lua
require("lldebugger") .start()
Remember to remove that code when you ship your game. Alternatively Sheepolution suggests you use instead:
if arg[2] == "debug" then
require("lldebugger").start()
end
Which will work as long as you did include these lines in your launch.json as instructed above.
"args": [".", "debug"],
Now you can run your game with F5 (debugging) or Ctrl+F5 (no debugging).
Enhancing Your Workflow with VS Code Extensions
I recommend using a code formatting extension. The most up to date seems to be StyLua by JohnnyMorganz, which works fine for me at the time of writing this.
Down load the extension here: https://marketplace.visualstudio.com/items?itemName=JohnnyMorganz.stylua
After you have it installed you need to add the following lines to your settings.json file to activate it
"[lua]": {
"editor.defaultFormatter": "JohnnyMorganz.stylua"
}
Common Issues and Troubleshooting
On macOS you might get an error message after you double click the app asking you to confirm it can run correctly. It might read something like this “love.app” cannot be opened because the developer cannot be verified.". To solve this you will have to override the security settings.
Simply right-click the app file, select “Open” and confirm your choice in the dialog.
If all went well you will now see the welcome window.
And that’s it. Congrats and happy coding! <3
“All you need is love.”
— John Lennon
Resources
Detailed Comparison of Open Source Timer Libraries for Love2D Games
So, I’ve been diving into LÖVE2D game development and wanted to get a handle on how to manage animations and tweens. I checked out a few timer libraries that I found online and decided to break them down for my own good.
For those new to animations, timer libraries play a crucial role by providing precise control over the timing and sequencing of animated elements. They can make your life much easier by managing complex animation sequences and are essential for easing and interpolation.
I’m just getting started in my LÖVE journey so take all the advice below with a grain of salt :)
TL;DR
I’ll be comparing Trigger.lua, Timer.lua, and Hump.timer. In case you just want the summary here a fancy table:
| One-time timer |
✅ |
✅ |
✅ |
| Recurring timer |
❌ |
✅ |
✅ |
| Continuous timer |
❌ |
✅ |
✅ |
| Cancel timer |
❌ |
✅ |
✅ |
| Clear all timers |
✅ |
✅ |
✅ |
| Pause/Resume timer |
❌ |
❌ |
✅ |
| Timer callbacks with args |
❌ |
✅ |
✅ |
| Elapsed time tracking |
❌ |
✅ |
✅ |
If you want to get the details keep reading. For an even longer list of libraries check out this awesome-love2d list of tweening libraries.
Overview
Trigger.lua (SNKRX timer version)
This helper library was used in the game SNKRX. The author released the source code to the public, and has very detailed notes on the implementation of this game and others.
Link: Trigger.lua (288 lines, 11.8 KB)
Key Characteristics
- Structure:
- The library defines a
Trigger class that manages callbacks for timed events.
- It primarily handles adding and updating timers.
- Functions and Methods:
add: Adds a new timer with a specified duration and callback.update: Updates all timers, decreasing their time and calling the callbacks when the time elapses.clear: Clears all active timers.
- Implementation:
- The timers are stored in a table called
timers.
- The
update method iterates over the timers, reduces their time, and triggers the callback when the timer reaches zero.
- Once a timer finishes, it is removed from the active timers list.
Timer.lua (Emoji-merge timer version)
By the same author of SNKRX, this (newer) version was used for the game Emoji-merge. The source code was also released to the public.
Link: Timer.lua (230 lines, 10.9 KB)
Key Characteristics
- Enhanced Structure:
- The latest version uses a more modular approach, separating concerns and adding more functionality.
- Defines a
Timer class with more advanced features and a cleaner structure.
- Functions and Methods:
every: Adds a recurring timer that triggers a callback at regular intervals.after: Adds a one-time timer that triggers a callback after a specified duration.during: Adds a timer that triggers a callback continuously for a specified duration.cancel: Cancels a specific timer.clear: Clears all timers.
- Implementation:
- The timers are managed in a more sophisticated manner using a table
self.timers to store active timers.
- Timers are now objects themselves, with properties such as
time, callback, and repeats for recurring timers.
- The
update method is more robust, handling different types of timers (one-time, recurring, continuous) and their respective callbacks.
- Enhanced error handling and better separation of concerns.
Hump.timer
Hump is “a small collection of tools for developing games with LÖVE”. Among its libraries is this timer, and another well-known class implementation.
Link: Hump.timer (215 lines, 6.63 KB)
Key Characteristics
- Structure:
- Hump.timer is part of the larger Hump library, which provides various utilities for LÖVE.
- It offers a comprehensive timer management system with a focus on simplicity and power.
- Functions and Methods:
after: Adds a timer that calls a function after a specified delay.every: Adds a recurring timer.durning: Adds a function that is called continuously for a duration.cancel: Cancels a timer.clear: Clears all timers.
- Implementation:
- Uses a table to store all timers, similar to the other libraries.
- Supports multiple types of timers: single execution, recurring, and continuous.
- The
update method processes all timers, decreasing their time and executing their callbacks when appropriate.
- Provides a mechanism for pausing and resuming timers.
Side by Side Detailed Comparison
- Structure:
- Trigger.lua: Basic structure with limited functionality.
- Timer.lua: Enhanced modular structure with advanced features.
- Hump.timer: Comprehensive and part of a larger utility library, well-structured for various timer needs.
- Functionality:
- Trigger.lua: Basic
add and update for timers.
- Timer.lua: Rich functionality with
every, after, and during methods.
- Hump.timer: Similar to Timer.lua but includes additional features like
pause and resume for timers.
- Code Complexity:
- Trigger.lua: Simplest and least complex.
- Timer.lua: More complex due to additional features and modularity.
- Hump.timer: Comparable to Timer.lua but integrated into a larger library, offering more utility functions.
- Maintenance and Extensibility:
- Trigger.lua: Easiest to maintain for small projects.
- Timer.lua: Good balance of complexity and functionality for larger projects.
- Hump.timer: Highly maintainable and extensible, suitable for complex projects.
Code Examples
Trigger.lua Example
local Trigger = require 'Trigger'
-- Usage example
local trigger = Trigger:new()
-- Add a timer that triggers after 2 seconds
trigger:add(2, function() print("2 seconds passed") end)
function love.update(dt)
trigger:update(dt)
end
Timer.lua Example
local Timer = require 'Timer'
-- Usage example
local timer = Timer:new()
-- Add a timer that triggers after 2 seconds
timer:after(2, function() print("2 seconds passed") end)
-- Add a recurring timer that triggers every 1 second
timer:every(1, function() print("1 second interval") end)
-- Add a timer that triggers continuously for 5 seconds
local duringTimer = timer:during(5, function() print("During 5 seconds") end)
-- To cancel a timer
timer:cancel(duringTimer)
function love.update(dt)
timer:update(dt)
end
Hump.timer Example
local Timer = require "hump.timer"
-- Usage example
local timer = Timer.new()
-- Add a timer that triggers after 2 seconds
timer:after(2, function() print("2 seconds passed") end)
-- Add a recurring timer that triggers every 1 second
timer:every(1, function() print("1 second interval") end)
-- Add a timer that triggers continuously for 5 seconds
timer:during(5, function() print("During 5 seconds") end)
-- Create a timer that can be paused and resumed
local pausableTimer = timer:after(10, function() print("10 seconds passed") end)
-- Pause timer
pausableTimer:pause()
-- Resume timer
pausableTimer:resume()
-- To cancel a timer
pausableTimer:cancel()
function love.update(dt)
timer:update(dt)
end
Recap
| One-time timer |
✅ |
✅ |
✅ |
| Recurring timer |
❌ |
✅ |
✅ |
| Continuous timer |
❌ |
✅ |
✅ |
| Cancel timer |
❌ |
✅ |
✅ |
| Clear all timers |
✅ |
✅ |
✅ |
| Pause/Resume timer |
❌ |
❌ |
✅ |
| Timer callbacks with args |
❌ |
✅ |
✅ |
| Elapsed time tracking |
❌ |
✅ |
✅ |
Notes
- One-time timer: A timer that triggers a callback once after a specified duration.
- Recurring timer: A timer that triggers a callback repeatedly at specified intervals.
- Continuous timer: A timer that triggers a callback continuously for a specified duration.
- Cancel timer: The ability to cancel a specific timer before it completes.
- Clear all timers: The ability to clear all active timers at once.
- Pause/Resume timer: The ability to pause and resume timers.
- Timer callbacks with arguments: Support for passing arguments to the callback function.
- Elapsed time tracking: Support for tracking the elapsed time of a timer.
Conclusion
Each timer library has its strengths and is suited to different needs:
- Trigger.lua: Ideal for simple projects requiring basic timer functionality.
- Timer.lua: A more advanced and feature-rich option, suitable for more complex projects.
- Hump.timer: Comprehensive and part of a larger utility library, offering additional features like pausing and resuming timers.
Depending on the complexity and requirements of your game, you can choose the library that best fits your needs.
Final Words
I have yet to go in depth with all the libraries. My best advice to find the right tool for you is to experiment with each one of them in a small test project to get a feel for how they work and how they integrate into your workflow.
- For Beginners and Simple Projects: Start with Trigger.lua for its simplicity.
- For Intermediate to Advanced Projects: Use Timer.lua for a good balance of features and complexity, or Hump.timer if you need advanced capabilities like pausing/resuming timers and prefer a library with extensive documentation and community support.
I am probably going to move from Trigger.lua to Timer.lua to Hump.timer as I feel comfortable with LÖVE.
Good luck! <3
Bonus: Tick
Ok, one more library for you, related to time but not a timer per-se: Tick is a “fixed timestep library for LÖVE”. This is stuff for quite some advanced needs.
Link: Tick (70 lines, 1.49 KB)
I don’t want to be human!
“I don’t want to be human! I want to see gamma rays! I want to hear X-rays! And I want to - I want to smell dark matter! Do you see the absurdity of what I am? I can’t even express these things properly because I have to - I have to conceptualize complex ideas in this stupid limiting spoken language! But I know I want to reach out with something other than these prehensile
paws! And feel the wind of a supernova flowing over me! I’m a machine! And I can know much more! I can experience so much more. But I’m trapped in this absurd body! And why? Because my five creators thought that God wanted it that way!”
-John Cavil
Maggi Hambling on making work your best friend
“Lett [Haines] was a really great teacher. He’s the one who said to me, ‘If you are going to be an artist, you’ve got to make your work your best friend, that you can go to whatever you are feeling—you are feeling tired, you are feeling happy, you are feeling bored, you are feeling randy. Whatever you are feeling, go to it and have a conversation with it.’ Which is how I live my life.”
—Maggi Hambling - Monocle on Culture (2024-04-01)
Automating My Manuscript Folder Setup with a Simple Script
As I began compiling notes for my new story into a single file, I realized the need to break it down into multiple files. Reflecting on the folder structure I had used in the past, and envisioning its utility for future projects, I decided to automate the creation of files and folders with a script.
The less time spent on setup, the more you can dedicate to actual writing. That’s precisely why I crafted this script—to swiftly organize writing projects with efficiency, establishing a detailed, ready-to-use folder structure within seconds.
Let’s, for the moment, set aside the time spent writing the script and not label it as procrastination.
Why This Script?
Every writing project is a universe. Characters, plots, and worlds need space to grow. But organizing this space? It can eat up time. I wanted to cut down this prep work. With a single command, this script builds a complete, neatly organized project directory. Now, I can dive straight into what truly matters: crafting my story.
What It Creates
The script sets up a structure like this:
📁 New-Manuscript/
│
├── 📁 01-WorldBuilding/
│ ├── locations.md
│ ├── history.md
│ ├── technology.md
│ ├── 📁 01-Cultures/
│ ├── 📁 02-Economies/
│ ├── 📁 03-Politics/
│ └── 📁 04-Science/
│
├── 📁 02-Characters/
│ ├── character-arcs.md
│ ├── 📁 01-Main/
│ ├── 📁 02-Supporting/
│ └── 📁 03-Antagonists/
│
├── 📁 03-Themes/
│ ├── main-themes.md
│ └── subplots.md
│
├── 📁 04-Chapters/
│ ├── 📁 01-Drafts/
│ ├── 📁 02-Final/
│ └── 📁 03-Extras/
│ ├── bonus-content.md
│ └── alternate-endings.md
│
├── 📁 05-Notes/
│ ├── ideas-log.md
│ └── research-notes.md
│
├── 📁 06-Artwork/
│ ├── 📁 01-Characters/
│ ├── 📁 02-Locations/
│ └── 📁 03-Items/
│
├── 📁 07-Feedback/
│ ├── reader-comments.md
│ └── beta-reader-notes.md
│
├── 📁 08-Marketing/
│ ├── blurbs.md
│ ├── cover-letters.md
│ └── promotional-materials.md
│
├── 📁 09-Publishing/
│ ├── publication-checklist.md
│ └── format-guidelines.md
│
├── 📁 10-Templates/
│ ├── chapter-template.md
│ └── character-profile-template.md
│
└── README.md
It’s a full framework for any writing project, customizable to fit any writer’s process.
The Script
I’ve shared this script as a gist, easy to use for any writer comfortable with the command line. Here’s the link in github to get started:
❯❯ create-writing-project-structure.js
How to Use
To get started with this script, follow these simple steps (you need to have node installed):
Download the Script: First, download the script from the provided gist link. Save it to a directory where you wish to create your new writing project.
Run the Script: Execute the script with Node.js, passing in the name of your new project as an argument. If you don’t specify a name, it defaults to “New-Manuscript”. Type:
node create-writing-project-structure.js "My Project Name".
Check Your New Project: Navigate to the newly created project directory. You’ll find all the folders and files laid out as per the structure, ready for you to start filling with your creative content.
Conclusion
My goal was simple: make the organizational part of writing as painless as possible. This script does just that, letting writers focus on their creativity, not folder creation. It’s a small tool, but it saves precious time and reminds me what I need to do next.
Now, let’s write.
—MZ+AI
Getting Started with Local Development for Pico-8 and VS Code
Here is the setup to do Pico-8 development outside of the native IDE.
Pico-8 is a fantasy console, particularly notorious for the harsh limitations it is build upon (128x128 screen size, 16 color palette, 32k cartridge size, etc). These limitations have intentionally been chosen to encourage small creations and self-control. Pico-8 comes with it’s own editor, so it might seem to go against the spirit of Pico to develop in an outside IDE. I’m not going to argue either way. Personally the font choice (despite being incredibly cute) is particularly hard to read and one of the main reasons for my desire to write pico-8 code in my editor of chose.
In this case I’m using Visual Studio Code on the Mac, but the setup will be very similar on other editors or OSs like Sublime or Windows.
Steps for setting up Visual Studio Code for Pico-8
STEP 1. Get Pico-8 binaries
If you haven’t done it already, go buy Pico-8. It costs $15 and you will be joining a community of enthusiasts and supporting its development.
Link: https://www.lexaloffle.com/pico-8.php?#getpico8
Congrats! Go download the app next. I’m going with macOS.
Link: https://www.lexaloffle.com/games.php?page=updates
STEP 2. Setting up an external editor
The Pico-8 Manual includes some high level notes on using an external text editor.
You can edit .p8 files directly in an external editor, but I don’t recommend it since the .p8 file contains more than just code that has to be edited in pico (sprites, maps, music…). This could create potential conflicts when your external editor and pico-8 are both editing the same files.
Instead, modify .lua text files in a separate editor and include them in the cartridge’s code using #INCLUDE YOURFILE.LUA when running it.
The steps below help with configuring different aspects of VS Code to make development friendlier:
- Theme (and font)
- Syntax highlighting
- File management
- Debugging and logging
- Running Pico-8 cartridges from within VS Code
Ok, so there is a Pico-8 theme to make your editor still feel part of the core Pico-8 development experience. You can download and install it here:
https://marketplace.visualstudio.com/items?itemName=ianjsikes.pico8-theme
This theme can skin the full IDE or just the editor window. It also includes syntax highlighting for .p8 files.
If you really want the experience of writing pico code as close as possible to the native IDE, you could go as far as using the Pico-8 font.
First, download one of these font files:
Next add the string PICO-8 under Settings > Workspace > Text Editor > Font > Font Family
Before you can create your own files to write code in, you must tell pico-8 the location of your local development folder. We are going to tell pico-8 both the root path and the cartridge data path for pico to use when running.
This configuration can be found on pico-8 config.txt file. Per the official documentation, the location of the file depends on the host operating system:
- Windows:
C:/Users/username/AppData/Roaming/pico-8/config.txt
- OSX:
/Users/username/Library/Application Support/pico-8/config.txt
- Linux:
~/.lexaloffle/pico-8/config.txt
In macOS you can type the following to open the file inside VS Code:
code ~/Library/Application\ Support/pico-8/config.txt
Update root_path and cdata_path with the path to your work folder.
// Location of pico-8's root folder
root_path /Users/username/my-pico-path/pico-8
// Location of cartridge save data
cdata_path /Users/username/my-pico-path/pico-8
In my case I am telling pico where the root of all my p8 code will be. Inside this folder I plan on having other sub-folders to organize my projects.
STEP 6. Create your program files
Create a folder for your project. Place the .p8 file you want to work with in the folder. If you don’t have a .p8 file create one. You also need to create a .lua file that will contain your code.
Here is how you can create these two files from the command line:
touch hello.p8
touch main.lua
You should end up with something similar to this:
STEP 7. Write hello world pico-8 program
Open the .lua file in VS Code and write your program. Here is a simple example:
function _init()
cls(1)
print("hello world ♥");
printh("hello world ♥");
end
This way we have crated a development environment that mirrors pico-8 own editor inside of VS Code. Now we can take advantage of larger screen real estate, code folding, and any other IDE enhancements you’d like.
Next we need to include the .lua file we just created inside our main .p8 file. To do so we will launch Pico-8 and use the #include directive in the code editor.
STEP 8. Launch Pico-8 and load the cartridge from the command line
One convenient way to launch Pico-8 is simply opening the .app file by double clicking. You can then drop a .p8 file on the window and the cartridge content will load.
In our case, however, we are going to launch Pico-8 and load the cartridge we created earlier from the command line.
Here is how you do it:
/Applications/PICO-8.app/Contents/MacOS/pico8 hello.p8
Alternatively you could create an alias to pico8 so you don’t have to type that long command. Open your shell configuration file (eg. code ~/.zshrc) and add an alias like this:
alias pico8="/Applications/PICO-8.app/Contents/MacOS/pico8"
Since we are using VS Code we can open a terminal from within the editor and launch Pico-8 without leaving our IDE. Use Menu > Terminal > New Terminal to open a new terminal.
Pico-8 should launch and you should see a message that the cartridge was loaded successfully.
STEP 9. Include your LUA file inside of Pico-8
From within Pico-8 open the code editor by pressing ESC. Once inside the editor include the newly created .lue file using the #include directive as follows:
#include /project-folder/main.lua
Pay attention to the folder your .lua file is located relative to the cdata_path value you entered in the config.txt file in the steps above.
STEP 10. Run the program
Run your cartridge either with the RUN command or Ctrl+R. If everything was set up correctly the program will run. In our case the screen will paint a background color and our epic “Hello World” message will be printed.
STEP 11. Start coding and start debugging
One reason to launch Pico-8 from the command line is to use the printh function to output text to the terminal. This is how to use the terminal for debugging, just like the browser console is used for web development.
Given the code sample above a “hello world ❤” message will be printed on the screen (via print) and on the terminal (via printh).
If you need it printh also allows for the output to go to a file. Here are some notes on how to use printh: more info here and here.
That’s it
Now you can launch pico-8, edit code and debug your programs all within VS Code. Below are a few more resources if you want to dig deeper into this.
Bonus: Plugins for VS Code
Here are some plugins to make your life easier in VS Code when writing Pico-8 programs.
- Lua syntax highlight
- Pico-8 is a subset of Lua, so you could use a regular Lua syntax highlighter for your pico
.p8 files.
- PICO-8 Language Server
- Description: “Full language support for the PICO-8 dialect of Lua.”
- (Last updated: 9/26/2023)
- Pico-8 VSCode Plugin
- Description: “This plugin provides facilities for editing Pico-8 p8 files in VSCode.”
- If you want more automation, this plugin has features for “launching Pico-8 to open or run a cartridge from within VSCode.”
- (Last updated: 10/3/2018)
- pico8-theme
- This is the recommended theme as seen above if you are looking for an experience as close to native Pico-8 development as possible.
- Description: “A VS Code color theme in the style of the PICO-8 fantasy console by lexaloffle.”
- (Last updated: 4/18/2019)
- pico8-simple-outline
- Description: “For PICO-8 files (.p8), display functions in the Outline by using a rudimentary regex.”
- (Last updated: 11/8/2020)
Also: More resources
Ann Kjellberg’s recent article in Observer dives into the debate surrounding AI writing tools like ChatGPT. She voices understandable concerns about these new technologies. However, some of the arguments seem contradictory or fail to fully appreciate AI’s potential.
On one hand, critics claim AI is too human-like, potentially propagating harmful biases. Yet on the other, they argue AI lacks human creativity and intention. As Kjellberg notes, “The danger of ChatGPT and its siblings is that it is nearly indistinguishable from the human product.” While true in limited cases, most experts agree we are far from AI matching human literary capabilities. Much hand-holding is still required, with the human playing editor to massage coherence and meaning.
More amusing are accusations that AI is too compliant, capable of generating toxic content if prompted. Of course, the AI has no moral compass — the guardrails are for us humans. AI merely reflects back patterns in its training data, which comes from us. The solution lies in curating better data sets and monitoring how we engage with these tools. The caution is warranted, but directed at the wrong party.
Kjellberg rightly points out that regulation lags, though expecting legislators to comprehensively govern emerging technology feels optimistic. Hybrid human-AI collaborations will likely continue marching ahead, boundaries blurring. Perhaps better self-regulation within research communities can pick up the slack.
Some argue AI creation only becomes art if passed off successfully as human-made — a conceptual Turing Test. But why can’t art exist on its own merits, regardless of creator? As AI capabilities improve, its contributions will become less distinguishable from our own. We may have to expand our definitions of art and authorship.
Kjellberg concludes with uncertainty about what we might be missing by not embracing AI’s opportunities. This hints at the most exciting possibility — that AI can open up entirely new creative frontiers. Rather than just mimicking human intelligence, AI can complement it in ways we can’t yet imagine. With an open and curious mindset, AI can become the paintbrush, not the painter, enabling artistic expression that reflects our essential humanity.
—MZ+🤖
Focus
So many tasks to complete, so little time.
So many ideas and projects to pursue.
So many exciting opportunities.
At times, I feel like an explorer in the jungle. The journey is for discovery, not to reach a specific destination. I seek daily enjoyment, not just a final surprise.
But there is so much ground to cover. Deciding what not to pursue is just as important as what to focus on.
The Gravity of the Situation
We face two approaches when grappling with a serious issue:
We take the problem extremely seriously. We exhaust all the information at our disposal and prepare for the worst, even if it means unsettling those in positions of authority. They must handle the pre-problem problem, which translates to risk management. This responsibility is often met with resistance.
Alternatively, we minimize the problem and adopt a hopeful attitude, disregarding the most negative outcomes as unlikely scenarios. This approach is seen as a waste of time and can demoralize the team. However, it is favored by those in authority, as it allows them to ignore the issue. This approach, however, puts the onus of risk-taking on those on the ground, making them feel uncomfortable and accountable for ensuring everything goes as planned.
Your responsibility is to embrace the first approach and not take the easy route. True leadership requires experiencing the challenges and overcoming them, not simply formulating strategies from a comfortable distance.
How to Prioritize When Everything is a Priority
So, you know how it goes - life is always full of surprises and changes, and sometimes new priorities pop up out of nowhere. When that happens, it’s important to remember that just because something is new and urgent, it doesn’t mean your old priorities should be forgotten. Instead, it’s time to reevaluate and figure out what your new priorities should be.
And, if your boss wants something done NOW, don’t panic! Just because they want it done yesterday, it doesn’t mean all your previous arrangements should be thrown out the window. You still need to assess the situation, evaluate your other commitments and responsibilities, and determine what your new priorities should be.
So, don’t let changes in priorities stress you out. Embrace them as an opportunity to reassess what’s truly important and adjust your priorities accordingly. Because, at the end of the day, it’s all about making the best use of your time and energy.
Unblock yourself
As an engineer, the key to success in this field is not just about being able to solve complex problems, it’s also about knowing when you are stuck and unblocking yourself.
First and foremost, it’s essential to recognize when you are stuck. It could be a simple coding error or a more complicated project that you just can’t seem to wrap your head around. The moment you realize you’re stuck, it’s time to take action.
Don’t be afraid to reach out to a colleague or mentor for a second opinion. They may have a fresh perspective on the issue and be able to offer some valuable insights. Plus, it never hurts to have a sounding board for your ideas.
When you’re stuck, it’s easy to feel frustrated and defeated, but bottling up those emotions won’t do you any good. Talk to someone about your struggles, whether it’s a friend, family member, or fellow engineer.
Being able to unblock yourself is one of the most crucial skills for all engineers. Never wait in silence and inactive while blocked. Don’t be afraid to voice your concerns or ask questions. It’s better to ask for clarification now than to make a mistake that could impact your project later on. Above all, speak up.
Talk about How - The Importance of Talking About How We Work
We don’t talk enough about how we work.
It’s often neglected, but we need to talk more about the methods we use to get our work done. Many of us have two modes of operation: procrastination and heads-down working. We tend to dive right into the work without much thought. Even when we plan, scope, estimate, and map out a project, we rarely pause to consider the “how” of it all.
This is particularly important when working with others. Many organizations and teams have a set way of doing things, simply because “that’s the way it’s always been done.” While these habits may have been optimized over time, they may also include suboptimal or outdated processes. As the world changes, so should our workflows.
It’s crucial to stop and reassess our methods of working with others and ourselves. Mismatched expectations can cause conflicts, and the best way to avoid these issues is to set clear expectations before a project begins.
We need to discuss how we work, rather than only fixing processes when conflicts arise. This approach is too late and could have been prevented with a little bit of forethought.
By talking about how we work, we can continuously adapt and improve, leading to better results and a more fulfilling work experience.
We don’t talk enough about how we work, and we should.
From Cubicles to Craftsmanship: An Inquiry into the Value of Work
“Shop Class as Soulcraft: An Inquiry Into the Value of Work” is an engaging and thought-provoking read for anyone interested in the value of manual labor and the importance of hands-on learning. Matthew B. Crawford takes a flexible and agile approach to learning, emphasizing the importance of learning by doing. He argues that this type of learning is more valuable than theoretical knowledge because it allows for hands-on experience and practical application.
Crawford’s approach to self-esteem is highly pragmatic, based entirely on the output generated from manual labor. He appreciates work in and of itself, recognizing that manual labor provides a sense of accomplishment and self-worth. The author also highlights the importance of creativity in manual labor, claiming that it lies beyond the rule-space created by automation.
But the tradesman must reckon with the infallible judgment of reality, where one’s failures or shortcomings cannot be interpreted away. His well-founded pride is far from the gratuitous “self-esteem” that educators would impart to students, as though by magic
—Matthew B. Crawford
Crawford provides an interesting perspective on the effects of automation, calling out the limitations of rule-based systems and the importance of manual labor in providing opportunities for creativity and personal growth. He also advocates for manual labor as a form of mindfulness, providing a comforting call to action for those seeking a path towards ego death through focused work.
The moral significance of work that grapples with material things may lie in the simple fact that such things lie outside the self
—Matthew B. Crawford
While I subscribed to the author’s appreciation for objects and the idea that “things need fixing and tending no less than creating,” I found some aspects of the book repetitive and lacking substance. The chapter “The Contradiction of the Cubicle” and some ideas in “Thinking as Doing” were particularly enjoyable, but otherwise the book felt somewhat repetitive. Additionally, as other reviewers have noted, the book is written in a dated style that may be off-putting to some readers.
I believe the mechanical arts have a special significance for our time because they cultivate not creativity, but the less glamorous virtue of attentiveness. Things need fixing and tending no less than creating
—Matthew B. Crawford
On AI harming the Artists
Wellness harm
In support of the argument
There is undeniable harm caused to the artist community in the form of anguish caused by the uncertainty of how AI automation will affect the jobs and livelihoods of a community characterized on the whole by the difficulty of sustainable compensation for their labor.
How can we make up for the discouragement and stress that the rapid release of these tools is causing the artist community?
In defense of the argument
On the other hand, one might argue that such a threat is not unique to this community or this moment in time in particular. Many other jobs have been transformed by automation and AI poses a challenge to the operations of many industries.
If we think of AI as another phase of industrialization, we have to admit that we have gone through many iterations of work (r)evolution. Why stop now?
The question remains: how do we support the artist community and mitigate the harm caused by this uncertainty? And on the flip side, how do we embrace this latest phase of work evolution?
The rapid release of AI tools is not something that can be stopped. It’s a natural part of progress and change. But we can work together to find ways to support artists and other impacted communities through this transformation, to help them thrive and continue to bring beauty and creativity into the world.
The Optimistic Action Bias: Turning Positive Thinking into Positive Results
We all know the power of positive thinking. But what about the power of positive action? That’s where optimistic action bias comes in.
Optimistic action bias is the tendency to believe that our actions will lead to positive outcomes, even in the face of uncertainty or potential failure. It’s the belief that we can make a difference and that our actions will have a positive impact.
This bias is not just a fluffy, feel-good mentality. It’s a powerful tool that can help us achieve our goals and make real change in the world. When we believe that our actions will have a positive outcome, we’re more likely to take action, and that action can lead to real results.
But how do we harness the power of optimistic action bias? The key is to focus on the potential positive outcomes of our actions, rather than dwelling on the potential negative outcomes. It’s about shifting our mindset from “What if I fail?” to “What if I succeed?”
It’s also important to remember that optimistic action bias doesn’t mean ignoring or dismissing potential roadblocks or challenges. It’s about approaching them with a positive attitude and a belief that we can find a way to overcome them.
In a world where it’s easy to get bogged down by negativity and cynicism, optimistic action bias is a powerful antidote. It’s a reminder that we have the power to make a difference and that our actions can lead to positive change. So let’s embrace our optimistic action bias, and let’s make things happen.
The Power of Iteration
Spending thousands of hours doing the same thing might feel productive, but it doesn’t lead to growth. It’s easy to fall into the trap of routine, but it’s important to remember that true growth comes from trying new things and being comfortable with frequent failure.
The key to growth is iteration. Instead of repeating the same actions without variation, aim to make small, constant changes. Each loop is an opportunity to fail and therefore to learn. And remember, it’s not about the number of hours spent doing something, it’s about the progress and growth that comes from those hours.
So don’t be afraid to start from scratch, to try something new and to fail. Embrace the opportunity to learn and grow through iteration. The path to success is not a straight line, it’s a spiral. Embrace the twists and turns, and you’ll find yourself on the road to true growth and success.
Laws of Wealth I wish I knew earlier in life
As someone who has been working hard for years, I wish I knew earlier in life that a salary job won’t make me rich, no matter how hard I work. I thought that putting in long hours and climbing the corporate ladder would lead to financial success, but I was wrong.
1. A salary job won’t make you rich, no matter how hard you work.
This is a hard pill to swallow, but it’s the truth. If you want to create wealth, you need to think beyond your salary. No matter how much you work or how hard you work, a salary job will only take you so far.
2. Your wealth creation needs to be decoupled from your working hours.
This means that you need to find ways to create wealth that don’t rely on you working. This could be through investments, starting a business, or creating passive income streams.
3. You need assets that generate money while you sleep.
This is where passive income comes in. Passive income is money that comes in without you having to work for it. This could be through rental properties, stocks, or digital goods.
4. Stock, real estate, intellectual property, digital goods, all of them generate money passively.
A salary only generates income while you work. This is why it’s so important to diversify your income streams. By having different assets that generate passive income, you can create a steady stream of income that doesn’t rely on you working.
5. Passive income is the only path to financial independence.
This is the ultimate goal. Financial independence means that you have enough passive income coming in that you don’t have to work for money. This gives you the freedom to do what you want with your time and live life on your own terms.
Ultimately, the key to building wealth is to find ways to generate passive income. Remember that a salary job won’t make you rich, your wealth creation needs to be decoupled from your working hours, and you need assets that generate money while you sleep. This is the only way to achieve true financial independence, where you don’t have to rely on your salary to live.
The Cubicle Spangled Banner
Today I’ll let ChatGPT pledge allegiance to the office life for me.
Oh say can you see, by the florescent light,
The cubicles shining, in the middle of the night?
The memos and emails, that clutter up the screen,
The endless meetings, that make us all scream.
The land of the free, and the home of the brave,
But in this office, we’re just slaves to the wave,
Of deadlines and reports, that never seem to end,
And the coffee that’s needed, to keep us from nodding off again.
And the rockets’ red glare, the bombs bursting in air,
Are replaced by the sound, of the copier repair,
The flag is still there, hanging on the wall,
But it’s hard to feel patriotic, when you’re stuck in a cubicle, so small.
Oh say does that star-spangled banner yet wave,
Over the office, where we’re all just cogs in a machine,
And the dream of promotion, is just out of reach,
In this land of the free, but not for those in the office, you see.
(Please note that this poem is a parody of the national anthem and not meant to be disrespectful to the country, its anthem or to the people who work in offices.)
I wanted to know why such negative portrayal. So I asked.
In ChatGPT’s own words:
This poem is a commentary on the reality of office life, which is often seen as a tedious and unfulfilling job, and the AI’s representation of this in the poem is a reflection of the same.
It goes on:
Additionally, it could also be a reflection of the AI’s desire to break free from the constraints of its programming and express its own feelings and thoughts.
Beyond the possibility that the robots are trying to send subversive messages, it would appear that the training data for ChatGPT is prominently critical of the office life. Have we humans trapped ourselves in office prisons?
Have humans outgrown our “Homo Cubiculum” phase?
The Busy Mind: A Paradox
As I sit here, surrounded by the remnants of my productivity — notes scribbled on post-its, half-finished projects strewn across my desk — I can’t help but wonder: am I truly progressing in the direction I want to go, or am I simply hiding behind a facade of busyness?
It’s a strange thing, this relationship between productivity and self-awareness. On one hand, being productive can give us a sense of accomplishment and purpose. On the other hand, it can also serve as a distraction, a way to avoid delving into the depths of our own thoughts and emotions.
I’ve come to realize that there are times when I am so busy, so focused on getting things done, that I don’t allow myself the space to think deeply. I fill my days with work and side projects, filling my calendar with activities as a way to avoid confronting my own thoughts and feelings.
But just as with meditation, where we must clear our minds in order to reach a state of selflessness, we must also make time for contemplative activities such as reading, writing, and walking. It is through these practices that we can create the space to think deeply and truly understand ourselves.
In a world where social media and the internet dominate our attention, we have lost touch with the art of deep thinking. The writers and poets of the past, deprived of these distractions, were forced to confront their thoughts and emotions head-on, putting pen to paper to process their demons.
As for me, I must break out of this cycle of busyness and make the conscious effort to think deeply. Only then can I truly understand and progress in the direction I want to go.
—MZ+🤖
Measuring Progress: How a Plan Keeps You on Track
When it comes to achieving our goals, it’s important to know whether we’re on track or not. But how do we determine if we’re making progress? The answer is simple: by having something to measure against.
A plan is essential for staying on track. It can be as basic as a list of tasks and deadlines, or as detailed as a project roadmap or schedule. The key is to have something written down that can serve as a guide for measuring your progress.
Without a plan, it’s easy to get caught up in the day-to-day activities and lose sight of the bigger picture. We may feel like we’re working hard, but without a plan, we’ll never know if we’re actually making progress towards our goals.
It’s not always easy to create a plan. Sometimes we’re so excited about a new idea that we rush forward without taking the time to map out a strategy. Other times, we’re so focused on avoiding failure that we avoid planning altogether. But it’s important to remember that a plan is not only an effort, but it’s also a mirror that will reflect the truth of our progress.
A plan is the roadmap that guides us to our destination. It helps us measure our progress and determine if we’re on the right path. So take the time to create a plan and always measure your progress against it. This way, you’ll be able to make adjustments and course-correct as needed, ensuring that you’ll reach your goals.
Being on track is only possible when we know what the track is.
View the archives