Mario Breskic : Social Wall

Hey everyone! I wanted to share a little story about a recent frustration that turned into a small coding adventure. If you’re into digital art, scripting, or just curious about how I hack my workflow with a Wacom and Photoshop, this one’s for you. It’s a mix of trial and error, some helpful AI assistance, and the realities of working with Adobe’s scripting quirks. Here’s how a simple idea grew into a few scripts I’m actually pretty proud of.

It’s probably well into Monday by the time you’re reading this, because I’m writing it a bit after midnight.

There was a minor grievance with how Photoshop doesn’t interact with my Wacom tablet; and that small annoyance somehow turned into two scripts (three, really) I built with the help of ChatGPT to address the issue.

What I wanted was simple: adjust the flow of a brush in Photoshop using the Wacom tablet’s Ring Menu.

The idea seemed straightforward: turn clockwise to increase the flow value, counter‑clockwise to reduce it; just like how you can zoom or rotate the canvas in Photoshop. I assumed there’d be hotkeys for increasing and decreasing flow that I could bind to the Ring Menu.

But those hotkeys? They don’t exist. Sure, you can use Shift + (0–9) to directly set the flow value, but that’s not what I was after. It’s functional, but not how I want things to work.

So I asked ChatGPT how a script would look that toggles a brush’s blend mode between Normal and Multiply, just to get started. I cleaned up the output using Copilot, admittedly got a bit carried away, tested it, and…it worked! At the push of an ExpressKey, I could switch blend modes.

I posted that script to Stack Overflow, asking for feedback on the quality of an LLM’s output. Turns out, they have a ban on LLM-generated content. Got my downvotes.

Anyway.

Next, I tackled what I really wanted: using the tablet’s ring input to control brush flow. I told ChatGPT what I had in mind, and got a script in return.

And it worked exactly as intended. It let me adjust flow by rotating the Ring—and it felt fast and snappy.

But there was a catch: it didn’t retain any of the other brush settings. Instead, it reset everything to Photoshop’s default brush when applied.

That’s when I visited the Adobe Community forums for the first time. I browsed around, read what others had done with ExtendScript—and I was genuinely amazed. I upvoted. I even commented.

Eventually, I posted my issue. [Here’s the thread, if you’re curious.] Someone responded and suggested I adapt a script from another post, and I did.

It worked. Kind of.

See, the adapted version was (and still is, as of this writing) slow. Unlike the earlier, snappy version that only touched the flow value, this one has to read, store, and then re-apply all the other brush properties every time it’s called. So if you do a quick half-circle on the Ring, you’ll be watching the flow change lag behind for a while after you’ve stopped rotating. (Fun fact: the Ring doesn’t physically rotate; Wacom employs witches and wizards, obviously)

But it worked and that’s something. Since the bottleneck is due to how Photoshop’s scripting interface works, not my implementation, I decided to upload the scripts to GitHub. For myself (should someone find a better solution), and for others (should this be the best workaround we’ve got).

At some point, I asked ChatGPT:

“This is so confusing. Why can’t we just add the changed value for flow to the existing brush settings, and leave everything else untouched?”

And it answered:

“TL;DR: You can’t just ‘set flow’ without overwriting everything else, because Photoshop scripting doesn’t support partial updates to ActionDescriptors.”

And that’s where things stand: somewhere between not as fast as it could be in a better world (where Adobe supports partial updates), and doing it all manually, dragging sliders around with the mouse.

The other thing I did this week was build a custom RSS parser in Huginn for my Goodreads “read” shelf. With ChatGPT helping me outline the approach, everything went surprisingly smoothly.

Since I wanted to post to Twitter/X and Threads every time I finished a book—and include its genre as hashtags—I started adding custom shelves on Goodreads for genres.

These genre shelves show up in the RSS feed that Goodreads generates, which made them accessible for automation.

However, because IFTTT can’t really parse RSS feeds to manipulate or modify content (like extracting specific info or adding hashtags), I turned to Huginn—a trusty old friend whose scripting language I had completely forgotten.

Thanks to guidance from ChatGPT and some trial and error, I ended up with an internal setup in Huginn that looks like this:

And it works! I expect to need some more tweaking, though. There’s a bit of randomness in the setup: ChatGPT suggested using a modulo operation on the date to select one out of six variations of the text “Read: [Title of book]” to send to the Output agent, so my posts don’t look exactly the same every time.

I’m not sure if or when I’ll add this script to my GitHub, but chances are good. For now, I really need some sleep; these late nights chasing dragons through trial and error must come to an end.

So that’s the update from my digital studio. Sometimes it’s just a small inconvenience that sparks the biggest creative experiments; and occasionally, a friendly AI and some forums can make all the difference. If you’re tinkering with Photoshop scripts, Wacom gadgets, or automation like me, I hope this gives you a bit of inspiration or at least a relatable story. I’ll keep sharing these little journeys as they come. Thanks for reading! This was fun!

Source: My after‑hours blog on Tumblr Code & Canvas