Since then, a lot has changed, including my perspective. As the principal developer for AppSumo Originals, AI has become a core part of my team’s daily workflow, especially on TidyCal, AppSumo’s scheduling tool.
The early models would write code that was close, but myopic. They’d miss much of the nuance of the problem they were trying to solve. I’d get a wall of code back that I couldn’t fully trust and had to read through line by line to catch the issues, taking me more time than if I had just written the code myself. I should have known that would be short-lived, but in the moment the frustration left me confused as to why AI was being pushed so hard.
Fast forward to today, particularly with Claude Code, I can lean on AI to write most things without me reading every single line. It’s developed the nuance that it so desperately lacked; it’s not just “ask and approve.” My time has shifted from writing code to having thoughtful conversations about what needs to happen, making sure we’re aligned on the requirements and edge cases before any code gets written. The gaps that come up are usually things I overlooked when defining the specs, not things the AI got wrong on its own. The entire process is much more collaborative.
Here’s where it’s made a tangible difference.
Speed and quality
Projects that took our small team a month before now take just a few days. New features that used to require days of scaffolding and wiring things up can be prototyped in an afternoon, which means we spend more of our time refining the product and less on the groundwork. Gone are the days of lingering bugs that were difficult to reproduce and pin down. AI can often spot the source of a bug in less than a minute and offer a fix in about the same amount of time. Not only is this a productivity booster, but also a learning experience if you take the time to understand what actually went wrong and how it’s being fixed.
Code review and the new bottleneck
It’s now possible to create an endless stream of PRs based on customer requests, bugs, internal ideas… you name it, that are “ready” to merge. AI has made the creation side almost trivially fast. But that shifts the bottleneck to the review process: are these changes objectively good to add? Do they actually solve the problem? Is the code sound? Does it follow existing conventions and patterns?
Code review is still a hands-on process for our team, but the nature of it has changed. A lot of it now consists of having a conversation with Claude about what’s broken, what can be improved, and then landing on the most important items to address. We delegate much of our GitHub interactions to Claude, but we’re still the ones behind the comments and the decisions. That feels important. Human oversight rather than letting an agent run unsupervised. Without that, you risk building up layers and layers of issues that compound over time. The team’s expertise and institutional knowledge are what keep the resulting work from becoming a purely vibe-coded product.
Non-engineers contributing code
Anyone can ask AI to open PRs with code changes, and that’s awesome. In fact, we already do this on the AppSumo Originals team. People in non-engineering roles contribute code with the help of AI, and current developers shift into more of an inspector role, making sure everything is up to code. (Pun intended.) Having someone with a strong technical background review those changes before they ship is still an important part of the process.
One of my biggest takeaways is that the skills which matter most now are communication skills. The more effectively you can communicate with AI, the better the results. Knowing what to ask, how to scope a problem, and when to push back on AI output all matter. Your performance is still largely tied to your ability to do those things well, and your desire to produce high-quality results.
AI amplifies judgment. It doesn’t replace it.
Knowing the codebase, understanding the business context, and having years of experience with the domain all matter more now, not less. AI can generate code fast, but someone still needs to know whether that code is right for the system it’s going into.
]]>Professionally we’re encouraged to use AI to increase productivity, and I can see why. It’s possible to ask an AI service to create something for you, and you’ll receive a very usable response which you can either then build on or use straight out of the box. I can’t help but wonder though; is this what work will look like in the future? Humans asking AI to do stuff for them, and essentially approving or denying its response? Will your performance be evaluated by how well you can ask AI to complete a specific task? Will it always been seen as just a tool? These are the questions that go through my mind.
Driverless vehicles have me pondering as well. Will there be a need for us to know how to drive if computers can do it better? Will driving eventually become obsolete, or even outlawed in an effort to minimize fatalities caused by the mistakes of humans?
Don’t get me wrong, the idea of leveraging computers to automate tasks is something I fully subscribe to. After all, it’s my profession and a great passion of mine. I’m just very curious about how AI will transform our lives, and what will be gained and lost in the process.
]]>Being a musician and a programmer I’ve always been interested in the MIDI file format and the possible web applications that could leverage it. When I first started programming I really wanted to do something with MIDI so I looked up the spec for the MIDI file format but was very intimidated by the details, like woah. So I shelved it and proceeded to build simpler applications, many musical in nature, which helped me build my skillset. What I like about about MIDI is how universal it is; once you have a MIDI file you can use one of the many applications available to play it, transpose it, notate it, and modify it.
Flash forward to the present; I thought it would be interesting to see if I could use the Web Audio API to record a single note and convert it to MIDI. I got to the point where I could detect the frequency and duration of the note and was ready to plug that data into a MIDI generating library for the conversion. Thing is, I wasn’t having very good luck finding a suitable JavaScript library that did what I needed. The thought of creating one myself crossed my mind so I went and took a second look at the MIDI file spec. I pulled up the same web page as I did years earlier and what do you know, it made much more sense than it did the first time I saw it. I actually understood how the hex values worked and what byte length meant! So at that point I was determined to put my programming knowledge to the test and write a MIDI file generator.
By combining this library with a pitch and rhythm generating algorithm you could potentially create unique pieces of music. With some basic constraints I would imagine you could get something sounding pretty good. Another idea I had was using this library to create audio “visualizations” of a dataset. For instance if you set some time based data to a beat, say one day equals one quarter note, and set the data points to pitches/velocity/octaves it could be consumed through the ears or even as written notation.
Of course you could also use this library in a more conventional way and incorporate it into some type of interface such as a piano roll or notation editor to provide a MIDI export feature.
The full documentation can be found on the GitHub page, so I won’t go into too much detail here. Though, here’s an example that should give you a basic idea of how the API is used to write the melody for “Hot Cross Buns”:
var MidiWriter = require('midi-writer-js');
var track = new MidiWriter.Track();
track.addEvent([
new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'}),
new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'}),
new MidiWriter.NoteEvent({pitch: ['C4', 'C4', 'C4', 'C4', 'D4', 'D4', 'D4', 'D4'], duration: '8'}),
new MidiWriter.NoteEvent({pitch: ['E4','D4'], duration: '4'}),
new MidiWriter.NoteEvent({pitch: ['C4'], duration: '2'})
], function(event, index) {
// Sets the sequential property to true for all events
return {sequential:true};
}
);
var write = new MidiWriter.Writer([track]);
console.log(write.dataUri());I ended up writing this script that basically goes through each comment and checks if another comment with the same content exists on the same post, and if so deletes it. It’s pretty simple I think and worked like a charm for me so I thought I’d share it here. Remember to always backup your database before running any kind of fixes like this, just in case.
]]>Basically it comes down to adding a filter which ties into the ‘post_class’ hook. Keep in mind that this will only work if the theme you're using implements the post_class() function, which pretty much all themes should use.
// Add 'initial_letter_post' class to post container
function initial_letter_plugin_class_filter($classes) {
$classes[] = 'initial_letter_post';
return $classes;
}
add_filter( 'post_class', 'initial_letter_plugin_class_filter');menuFlip is a jQuery plugin for adding a flipping, marquee type effect to text based navigational menu items when hovered over without needing to use background images, which can be a pain.
All you need is this simple markup.
<ul id="flip_nav">
<li><a href="/home">Home</a></li>
<li><a href="/web">Web</a></li>
<li><a href="/blog">Blog</a></li>
<li><a href="/contact">Contact</a></li>
</ul>You can optionally specify the text you want to use for the flipped menu item using the data-flipped-text attribute in each link:
<li><a href="/home" data-flipped-text="Flipped Text">Home</a></li>$('#flip_nav).menuFlip({
li_height : '20px',
flip_speed : 150,
flipped_class : 'flipped_item',
mouseover : function() {},
mouseout : function() {}
});No extra CSS is required for this plugin to function, but you'll probably want to define a width for the ul or float the li elements to the left so they are inline. Also, the flipped items have a class of flipped_item so you can style that puppy as you like. Here's an example of the CSS for the above example:
ul#flip_nav li {
float:left;
text-align:center;
margin:0px 10px 0px 0px;
}
/*this defines the styling of the new flipped menu item*/
ul#flip_nav a.flipped_item {
background-color:#000000;
color: #ffffff;
}It may be simple, but I haven't really used javascript's confirm() function much in the past and everything I found only directed the user to a link predefined in the function. I wanted a function that would confirm any link I wanted it to without knowing the link destination in advance, in other words I wanted to confirm dynamic links.
This jQuery function will pop up a confirmation box on any link with the class confirm and send the user to the destination of that link if they click 'OK'.
$(function() {
$('a.confirm').click(function(event) {
event.preventDefault()
var url = $(this).attr('href');
var confirm_box = confirm('Are you sure you want to click this link?');
if (confirm_box) {
window.location = url;
//uncomment below and remove above if you want the link to open in a new window
//window.open(url,'_blank');
}
});
});<a href="http://www.grimmdude.com/contact/" class="confirm">Link Example</a>To create a text box in a post or a page use this shortcode:
[textbox rows="3"]Contents of text box[/textbox]
Options are as follows:
rows Number of text rows. This will determine the height of the text box. (optional)width Width of the text box in pixels. (optional)code When set to true the content of the text box will not be escaped. Useful for including code snippets. (optional)class Specifies a custom class to use on the text box. Useful for styling. (optional)