Overcoming a Steep learning curve

Developing from principles To Solve problems.

Lately, I've been automating my video editing. Learned a lot in the last few days, so recently, I asked an LLM to evaluate my skill level based on a chat I had running while learning how to write scripts to perform repeated tasks. Here's what it said...

It seems like these days, the barrier to entry for software development is getting more accessible. Keeping an eye on the machine learning trends, I’m seeing more capability to automate the process of writing code, but does that mean that just anyone can do it? I’d argue not, or at least not without some foundational knowledge. We’re talking principles here, and that’s why I found this analysis so interesting. It is a great example of what I wrote about in my Meta Learning article the other day, speaking to the idea that learning from principles provides a better foundation upon which to build.


Thanks for reading Cody Gene's Substack! Subscribe for free to receive new posts and support my work.


”Based on our conversation, I’d describe the skill level as intermediate to advanced, with a strong focus on practical problem-solving and customization within Blender's Video Sequence Editor (VSE). Here’s why:”

Now, I would view this period as the intersection point between beginner and intermediate skill levels. There was something in my mind that simply didn’t click. I knew enough to know how much I didn’t know, some core principle about how data is structured and formatted, but I couldn’t place exactly what that was. I needed to “get my hands dirty” to figure it out, trial-by-fire and all that. It’s a great way to get experience…

”Python Scripting: You're comfortable reading, writing, and troubleshooting Python scripts. You have experience navigating Blender’s API and addressing specific VSE tasks.”

My aim here was to work with executable scripts since it didn’t require anything sophisticated besides a few lines of code and some .py files. I figured this exercise would allow me to create something useful while keeping it simple.
“Problem Analysis: You effectively identify discrepancies (e.g., frame_start vs. actual strip positions) and propose logical solutions, like calculating ranges or using offsets.”

I considered the problem I was trying to solve. In this case, I had repeated functions in the video editing process that were time-consuming. I knew that I could automate most of them to save clicks, and thus time. This involved learning the functions that were available to me, what they were called, and logically thinking through how they could be applied.

”API Familiarity: You understand Blender’s properties (e.g., blend_alpha, frame_start) and know how to manipulate them programmatically.”

I discovered that my exercise would call upon pre-existing functions built into the software. This was a big eureka moment for me since I knew I had to tell my script to do something but I wasn’t sure how (at first). Turns out that the API call was the missing link, first telling the code where to look, then what specifically to look for, and then systematically calling the desired actions with a lot of experimentation, a lot of trials, and of course error.

It reminds me of this advice I read recently. Turns out I was doing this automatically.

”Failure is fuel. But many are afraid of it. The faster you run toward it, the faster you’ll grow. Stop tiptoeing around mistakes and embrace them. If you’re not failing, you’re playing it too safe. Want to grow fast? Fail faster! That’s how you learn, adapt, and dominate.”

”Automation & Optimization: You're exploring automating tasks, such as rendering multiple meta-strips or dynamically animating properties, which demonstrates advanced thinking about workflow efficiency.”

Workflow efficiency is an interesting concept to me, closely tied to the idea of beginning with the end in mind. I’ve always believed it is much more effective to start with a clear intention. The entire process doesn’t need to be fully developed, but the idea should be, so rather than stumbling around figuring it out as you go, and it’s not like there won’t be things to figure out along the way, the more structure that’s formed in advance, the better.

Debugging: You can analyze error messages, hypothesize causes, and adapt to resolve issues effectively (e.g., addressing float vs. int issues or understanding MetaSequence quirks).

In dealing with the many stages of trial-and-error in this experiment, there was a lot of logical thinking. The ability to not only ask questions but to ask relevant questions to find solutions to make the thing work was important. Sometimes it was a typo, which a bit of attention to detail helps to solve, while other times it was a problem in the flow of how I approached the problem. In the latter case, I had to seek an alternative method to achieve the same ends. There was a lot of creativity to it. There’s an art to everything I suppose…

”Exploring Complex Workflows: You've shown interest in optimizing rendering workflows (e.g., setting ranges, downscaling, codec changes) and integrating them seamlessly into production.”

This process was a lot of zooming out, acknowledging the skill level I was working at while asking myself “How can I achieve this simply?” I decided that not everything needed to be automated in the same script, but rather a series of modular components that could be mixed and matched as needed. Each script would do one thing, and I could adapt my workflow to apply them as needed. Not as advanced as it could be, but a quick and dirty solution to the problem at hand. The goal was to make a few for the most common repeated tasks, get them working, and store them in such a way that i could reuse them in the future.

”Interest in Broader Development Patterns: You've expressed curiosity about structuring code using OOP, making scripts modular, and improving readability—hallmarks of advanced coding practices.”

These interests came intuitively. It didn’t make sense to simply write a script to do a thing, I wanted to have something I could keep on hand to expand on as my skill level improved. I suppose its the idea of forward-thinking. Knowing that if someday I wanted to return to further develop this library of scripts, I don’t want to restart from scratch. I’d need to structure this in such a way that facilitates reusability. As it turns out certain programming principles can be applied to achieve this. I simply had to start asking the right questions to discover what they were.

I've been challenged by the combination of logical thinking and creativity that came with the experience, starting with a question I asked myself. 'okay, I have this thing I want to do, how can I do it?

to me, these are the types of skills that, despite the steep learning curve, will prove worth their worth over time. I believe it should be possible to self-direct my learning in this direction, simply by building more things I find useful.
Thanks for reading Cody Gene's Substack! If you enjoyed this story, Subscribe for free to receive new posts and show some love to support my work.

---