The Disclaimer Section

before i get anywhere near the nuance, id like to make a couple of things pretty clear. because everything i say here comes with some heavy caveats.

• AI is Exploitative: this is obvious. it's trained on human material and is then both used and marketed as a replacement to the working class. in a better world this would be good news as it'd leave people with more free time to pursue their own passions and endeavours. then again a better world wouldn't be dominated by capitalism - so we have to be more realistic here.
• AI is Expensive: in every single way, or at least it strongly tends to be. when you're racing with AI, you don't really have much of an incentive to innovate. instead, the victory condition is getting the most compute, after all more numbers means more better. Not all models pursue this path though, some attempt actual structural improvements that cause dramatically better efficiency. Unfortunately, those models aren't the one in the limelight.
• AI is Obnoxious: this is the least important, but it is still worth pointing out. the field is so obnoxious. all hype is either engineered, or parroted, and it is always the corniest shit. the people who repeat platitudes and hype only tend to inspire a seething rage that's usually followed by a tightly held fist. this is not a hype piece. at best, this is just me talking about my experiences after i finally gave it a shot.

The Thesis

now that we got that out of the way, let's get my main point across. AI can be incredibly useful when it comes to research and programming - if you keep certain things in mind. the second part is more important than the first - fail to consider that, and it'll be actively harmful instead.

it's no surprise that AI isn't an oracle. it frequently gets things wrong, but it lives at that boundary between frequent bullshit and complete truth that is insidious in a different way - so i need to be extremely clear - all AI use should come with guardrails. any power or trust you give to an AI should be assumed to have the potential of going catastrophically wrong - forget that, and your data might just get wiped.

something to keep extremely close to your mind is that in truth, these AI are just mimics. i won't go deep into detail on this here since i think most people are familiar with the main problems, but i advise you learn about the Chinese Room Thought Experiment. incase you're not aware, the thought experiment points out something that feels a bit obvious: cheating can fake understanding. AI isn't actually understanding anything you're saying, it is just using it incomprehensibly large dataset and essentially brute forcing a response that makes the most sense.

there's nuance there of course, however the reason why I bring this up is simple. language models can be very convincing. but the same way you wouldn't trust a person with your powerful credentials unless given very good reason, you should work the same way with an AI as well - or at least understand the problems. the moment you give it access to your credentials, you run the risk of it using them in a way you wouldn't have wanted - no matter how many times you tell it not to. it has a memory, and it can forget, and its "memory" is a lot worse than us humans.

now, keeping that in mind -- it is still pretty good. consider that, even with the thought experiment, you are still getting mostly good results - you just shouldn't collapse that into a trustably certified output - everything should still be verified - similarly to how you shouldn't blindly trust search results, because anyone can just make shit up on the internet. however, it has two very major benefits to it over the more manual methods.

but first, a real-life case to explain why I'm about to say the things you'll see here.

A Real Life Case: AESTHESIS vs Image Toy

some steps back since that title is likely causing actual question marks to pop up over your head.

AESTHESIS is a project im working on which has had previous iterations written entirely manually - and the core of it is:

1. You specify a configuration of effects, with parameters that can either be hardcoded or pseudo-randomized according to limits you set for it.
2. You specify a number of iterations, and an input medium (image or video).
3. It executes, and creates N results based on the configuration you specified.

in less terms, it is a batch visual effect generator. Image Toy is the previous, completely manual iteration, and AESTHESIS was an attempted complete rewrite based on a core fundamental improvement - using GPU for effects instead of the CPU. there's just one problem. the process of learning wgpu makes me want to drive spikes into my eyes.

so, after giving the tutorial a shot and falling off multiple times, I decided hey. let me ask AI. the documentation is right there, so maybe it can synthesize some sort of explanation and approach that works far better for me, especially when i specify what my use case is.

help w/ wgpu

one of the first things I learned is to not have a "Surface". now i didn't even know what a "surface" does, but the tutorial made me do it as part of the introduction. however, the response said that for my case it's not providing much benefit at all - because a "Surface" determines a place to display the output - which in the tutorial's case, is a window. and clearly I do not need a window here. so suddenly, I not only simplified my code by taking out a chunk that was providing no benefit to me, but I also had more of an understanding regarding whatever a "Surface" was. this was very easily confirmable by looking at the code myself.

so, considering the success of that, I decided to ask it for a more thorough exploration of wgpu. and it came back with a solid enough summary - so i just asked it to elaborate further, and cross-referenced the tutorial code to see if it made any sense. and soon enough, I had a pretty solid foundational understanding of wgpu. so much so that I can summarise a big chunk of the pipeline right here:

• Instance: An actual "instance" - the core of the library that everything comes from.
• Adapter: An abstract interface that connects you to your GPU.
• Device and Queue: "Requested" via the adapter, and represents an actual logical interface to the GPU that you can use to interact with it. The Queue comes along because it's how you actually setup what to execute.
• Shader Module: Represents a shader file itself - pre-"compilation" - meaning it doesn't have any parameters or logic set - it is just a blue print.
• Bind Group + Layout: Starting with the layout, it defines a "contract" for the parameters of the shader. It should match the parameters defined in the shader file - and no, as far as I know this can't be done automatically. The group itself has the values baked in - so in other words, the layout is the contract you only need to do once per shader, whereas the group is the "fulfillment" of the contract.

i can keep going, but this isn't a wgpu tutorial. the point is, i honestly only fully understand the point of these things after querying AI - and while the tutorial would've likely eventually helped me get the understanding, the way it was presented just didn't work well for me enough to get to that point. this is one fundmanetal benefit to an AI - you can actually talk with it and specify your requirements and what you're actually interested in, and it will synthesize a response back.

in other words, with online resources you only ever get the one presentation. and since different people are different, not everyone will benefit as much from the same presentation. AI essentially lets you "translate" resources into a language that's optimally tuned to your specifications - which I mean, they're literally called Large Language Models, it's the one thing they're experts at.

this is just an early case scenario by the way - because AI was able to scan the codebase very quickly, I was able to ask questions about the current architecture, and even suggest changes to it. and because of how much knowledge is embedded in the model, all of the best practices and "tricks" of the industry are also located in there, floating around in the whole soup. so for someone who's a beginner in the field, it doesn't just help with learning, but it also helps with finding out what to learn.

split video to frames vs. keeping in memory

this goes into my second story - Image Toy did work with videos, but it did so by using ffmpeg to split the video into all its individual frames alongside the audio, apply effects to the frames, save the result, and then recombine it. this worked, but was also grossly inefficient. of course, I knew that bit, but I thought that any alternative solution would not only provide small benefit, but would be an overcomplicated nightmare.

so then comes a day where I ask the AI to "audit" my source code by going through it and seeing what all the potential improvements are. and amongst all of them was this - a note on how my approach to working with videos is more inefficient than I thought, because the I/O bottleneck of needing to save each frame of the original medium, as well as all the outputs, was actually quite considerable - so it suggested I just pipe the footage directly.

oh, why didn't I think of that? how the fuck would I do that.

and so, it told me. there's a dependency i was using which makes the process easier than it would normally be - ffmpeg_sidecar, and it allowed me to essentially read the file directly into memory, and then pipe it out as RGBA frames that I could then convert into textures that could then be plugged into wgpu to apply effects. and then it offered to do it for me. so i let it, since i wanted to see what this code would even look like, and if it was some hallucinated detail.

and wouldn't you know it? it made sense. and it worked. so now i had an example where i was doing something which just a few moments before, felt completely unapproachable because of all the other flashier improvements that I was focusing on instead.

these are two stories, but I can very much keep going. for example...

pixel sorting on the gpu

back when I had no idea about how to even start pixel sorting on the GPU, because the whole thing about the GPU is that it works completely in parallel, so something like sorting which doesn't is a big problem. i'd found this article by cipherd - and though i could understand parts, i had absolutely no idea about the whole thing as a cohesive piece, and even though the code was attached, i couldn't exactly understand it considering i had basically no experience with shadercoding at all.

so, i asked ai, which had access to my codebase, how i would go about understanding what it's doing, and integrating it into AESTHESIS. and that unlocked everything, and the learning floodgates opened.

1. PING/PONG is a technique where you have two textures - and you treat one as the input and the other as the output.
2. The ODD/EVEN sort works by sorting a pixel with its neighbour - and alternating the comparisons. So for the simplest example where you have 3 pixels (A, B, C), you'd first compare A to B, and then B to C. Then back to A to B, and keep alternating.
3. So a single step will perform one instance of the sort, and place the output in the output texture as per the PING/PONG.
4. To fully sort the image, you'll need N passes, where N is the largest dimension. So for example, to fully sort a 900x1600 image, you'll need 1600 passes. However, you can go lower for more stylistic options.
5. The vector-based innovation is simple in a clever way - instead of just comparing neighbours, you can generate an alternating vector field with the same size as the image - and to find the "neighbour" for any pixel, you just refer to the pixel at those coordinates in the vector field, and pick a direction based on the colour. For example, Red means horizontal, Green means vertical, Blue determines the sort order.

...and then it helped me architect what that'd look like in AESTHESIS. by which I mean, we effectively designed, in collaboration, a system where an "effect" can have multiple passes inside of it, using internal ping/pong textures, and this generic implementation would allow for arbitrarily complex effects to have any amount of "passes".

People may have read the article and thought, "well duh" - but I swear to you, no matter how many times I read it, I could not figure it out.

the feedback effect-class - and why you still need to focus

this one is a different example -- feedback is very simple, you just need to keep the last output. then you can use it to apply feedback effects - for example, you grab the original image, and you overlay the feedback on top of it. this builds up over time, and causes some pretty interesting effects.

on my end, i basically had one idea on how to use this. i wanted an effect bleed, where the "feedback" kinda "leeches" colours in different directions - for example reds drifting to the left, greens to the right, blues down, etc... and this is where the bleeding comes from - due to how feedback works, the colours keep moving in the same direction and building up. it's a pretty nice effect, but feedback felt like it had way more potential mechanically than just this - i just struggled to think of suggestions.

so i asked AI. and it answered with some pretty interesting suggestions:

• Ghost Trail: This one was mostly missed by me - but if you remove the "bleeding" entirely, then the feedback effect just stacks as a "ghost trail", which causes some motion smoothing. I didn't consider it since it felt boring, but this was a good reminder that yeah, probably good to keep note of that as a separate effect, even if it's replicable with the normal feedback bleed.
• Infinite Zoom: I didn't make the connection that this would also work with feedback. If you just zoom and rotate the feedback a bit, it'll stack on each other and cause an infinite zoom effect. It's not perfect since the feedback needs to be overlaid, so some obstruction will happen - but it's another "obvious" suggestion that didn't come to mind.
• Displacement: I was thinking about displacement map as an effect, but never got around to it. Incorporating feedback feels obvious in retrospect, but something that I don't think I would've found (I tried and yep, couldn't) is a github repository by baku89 which stored an example implementation of this. The model found this example and used it as inspiration, while explicitly telling me about it so that I could check it out.

displacement is a very interesting case here, because it's where we had a "feedback" loop of our own. the implementation looked broken, but I didn't know if that was because of a bug, or because the effect just looked like that. I checked with the AI, and sure enough it told me that the effect worked like that. I said okay... but the doubt never left - so I checked the original repository, and noticed that the examples looked wildly different.

and infact they gave me a thought. so I asked the AI something like this:

"the examples in the repository are very different, and i'm beginning to wonder if their project is applying the displacement on the feedback itself rather than the input image - because that feels like it would have more consistency. because trying to displace the source image seems to just cause too much chaotic broken movement."

so it took another look - and wouldn't you know it, I was right. we were applying the displacement on the wrong texture. evidently, the AI would've had some strong difficulty finding this out on my own, and were it not for my human input, we'd likely be stuck with the broken implementation.

to me, this proves something - that AI is not a replacement, but an augment. it can be used to augment your abilities - to have considerably more speed and contextual professional information - but it must be guided and treated correctly. without human input it can act on its own, but it can go catastrophically wrong - be it with trivial flaws in information or reasoning, or dangerous actions.

or, putting it "mathematically":

• only human: careful. slow but deliberate. hallucinations don't exist, instead we have normal human fallibility, which is nowhere near as catastrophic.
• only ai: extremely fast, extremely knowledgeable. can easily compound hallucinatory flaws into itself, which can just as easily cause catastrophically bad results, as keeps getting proven.
• human + ai synthesis: human for the more dependable reasoning, creative guidance, suggestions and much more trustworthy wisdom, in addition to being able to "store" knowledge independently - ai for the speed and filtering to drastically accelerate the underlying workflow.

or putting it another way - a factory of just people will be inevitably slow. a factory of just AI can easily cause a chain reaction of failure that can go catastrophically wrong very fast. a factor of AI with human overseers can mitigate the issues of both, while enhancing the benefits -- with far less friction for humans, and far more wisdom and guidance to pilot AI away from the cliff-edge.

The Workflow

up til now, you've had my stories of what i went through - but now it's time for me to describe the "workflow" of how one could use AI - because the real challenge of this whole process is the balance. it's not a binary choice, where you can just get an AI and that's it - you are the Overseer. a big part of that is choosing how much you want to oversee - and this means a gradient.

the main part is that you set your own guard rails that you as an overseer hold yourself to. if you are too restrictive, then you're cutting into the benefits that AI gives you. if you are too liberal, then you're essentially purchasing a time bomb which will catastrophically blow up in your face one day - the only question is when, but it will blow up. this end is where most AI hype ends up - people who delegate everything to the AI, doing things such as vibe coding where the agent basically does all the programming with only surface level directions from the people involved.

like with many things, the best place to be within this gradient is one with enough balance.

for example to me, it depends strongly on my confidence level. for AESTHESIS, I make an effort to manually review the code changes so that I can understand the implementation. though I am very confident in Rust, it also has a pretty high skill ceiling, and I am completely new to many aspects that I'm working with, such as wgpu and graphics programming in general. as such, while i do let it code stuff up, i also make sure to understand what it is doing - so that if the AI blows up, or I lose connection, I can continue the progress on my own - just at a much more human pace. it's also out of curiosity - i genuinely care about the field, and having something which is basically an advanced research engine that can "dummy down" things to a point where I can build enough of a solid foundation to understand more, is pretty useful. the results are also pretty trustworthy, because they are self-evident --- if code is wrong, the output would reflect that, be it a broken build, or results that are buggy.

this is something really nice with coding, it can sort of self-audit. and especially with Rust which can be strict, it becomes trivially easy to ensure that the principles and strategies being applied actually work.

however for example when it comes to web development, I'm more lenient. not only is there a much wider plethora of knowledge of examples about web development, but the field is enough of a clusterfuck to where it's very trivial to run into an annoying issue because of a typo or some secret magic. ive gotten enough experience to where i can pretty easily understand web development code that i look at, especially if im familiar with the framework, and even if it's complicated. because my main pain point with web development is that when bugs do show up, I end up wanting to put my router in the oven - because the debugging experience is almost universally miserable. so if you tell me an AI can help me bypass the step where I browse through tons of sponsored, SEO garbage, or stack overflow entries that may only tangentially be related to my issue, until one appears for my use case that is met with the equivalent of a "go fuck yourself", JUST so I can hopefully run into the one result to rule them all that actually accurately describes the issue and solution, maybe, eventually, if I don't eureka-brute-force my way into the solution first...

...well i mean the choice is very trivially simple there.

now, the title is generic - and I do mean it. although I was mostly talking about code here, I do also mean research - it can be very useful for that, but again - as I hope you've cemented into your mind by now - only with the right guide rails. infact, i think there's some golden guide rails here - so let me list them.

The Golden Rules

Thou Shall Rely On Web Search

Use web search. Make sure it's turned on. The internet is not a beacon of trustworthiness, however it provides a referrable context where you can map a synthesized output from an AI to the raw entries that led it to say those things. This then enables you to manually verify what the AI is telling you - in essence, you can treat it as a glorified search engine. Now, of course it's not a replacement for it - but if you either

1. want an answer now and don't want to just depend on the first result that pops up considering it could either be an ad, or some SEO garbage
2. want a very solid starting point for your research, without having to dig through the trash pile yourself and manually build your own syllabus from scratch

...then it's useful. In other words, it's the bootstrap strategy -- it's not replacing the process you'd normally go through. It just provides a good starting point for you to work from - helping you get better quality results faster.

Thou Shall Use References

Use references extensively. This is a big reason why you should use web search, but it doesn't just have to be that. You can also ask the model to try and refer to sources that reflect the information it's about to tell you. These can be broken of course, since rather than coming from search results that just happened, it basically has to pull them from its training data, which would be compressed to shit. However, you can pretty easily make sure the reference isn't bullshit by just... checking it. It's not that hard, it won't even take you that long. It's extremely worth it, considering the case where the AI is just making shit up.

Thou Shall Have A Comprehensive Understanding

This one is critical. Never tell the AI to act, without letting you understand the process and the reasoning that led to it. Always understand what it is doing and why. Not only is this helpful for you to accumulate knowledge, but it also keeps your skills of manual information acquisition sharp. Learning is a muscle, and it's one that you should definitely keep trained - so cementing comprehension of techniques and information helps keep you sharp, with the references/validation helping to make sure you're actually learning, and not stuffing complete nonsense into your head.

Thou Shall Retain Memory

How annoying is it to write your own notes? It's very useful, but sometimes - say if you have ADHD - you simply cannot be fucked to write notes covering everything that you've learned or covered, and thus end up just... never writing it down, and instead just keeping it in your head.

This step would be amongst the final ones in an AI-augmented workflow - you'd have a session, meaning a conversation, and at the end you can tell it to summarise - preserving all references, and adding any missing ones - and create a note for you. It's much easier to read notes than to write them in my opinion - so then you can just read the notes, and go from there. At the very least, it's better to have a resource than just not storing anything anywhere - and honestly it's a good bootstrap for building your own notes on top of as well.

In addition, remember that sessions don't share memory with each other. Meaning if you start a new session with the AI, it will not remember what you were doing before without reminders. So these can also be used to have a different instance audit the summarised notes, and see if there's any issues it can pick out in them. In addition, if you go to verify your own notes and notice some issues, you can point this out to see if maybe you're missing something, or if you're correct, at which point it can fix the issue thoroughly throughout your notes due to its much better speed.

I personally keep a historical record of some important information - because anytime I try to have a system where I take notes myself, I always end up dropping it at some point, which defeats the purpose. Any notes, even if AI-generated, are better than no notes - especially when the AI-generated notes come with a very wide plethora of references and sources you can browse to confirm things.

Just always keep in mind - AI can hallucinate. References and sources aren't guarantees - they are tools that help you make sure it's not making shit up. Essentially, treat the whole thing as if it's being said to you by someone charismatic. No matter how convincing they are, you don't know if they know what they're actually talking about. So you should verify to make sure. But also, you clearly don't verify everything everyone says, because you also have your own knowledge and can on some level make the right judgment, given the right scope and question. Like if an AI says that 2+5 is 8, you don't need to do research to find out that that's completely incorrect.

Thou Shall Consult Experts if Possible

If you can, you should still try to check with experts as well. You don't need to obsessively ask them - realistically you can simply work on a project, and then check with an expert to get a more reliable perspective on issues to fix. In terms of understanding and reasoning, AI is nowhere near the level that a human expert would be. If you can ask for a codebase review, definitely do so. If you cannot, then at the very least you should do actual research on articles made by experts in the field. If you're using AI correctly - you should already have had articles and resources shown to you - and you should already have checked them. At the very least, keep track of the links so a more-experienced/mature you can review them later on.

Thou Shall Audit Thy Confidence

It's all too easy to feel misplaced confidence - remember that these are language models, and will inherently, even in the best of times, have some flavour of sycophancy to them, because that is what works with keeping people attached to a service. Of course, confidence has a place, but it needs to be earned. So if you feel confident, make sure to audit yourself. Skim the codebase, how sure are you about how things work and link together? Are you able to trace the full execution flow, including branches, from beginning to end? If you had to sit down and write out the entire architecture and functionality of the project, how much would you be able to write?

And most importantly - when you cross-reference with actual trusted sources, how much do they match your "confident" outlook?

The key thing here is to appreciate if misplaced confidence shatters - because it means you have a lot more to learn, a lot more potential to realise than you thought you have. Don't feel disheartened - even in the worst of cases, the amount of progress made will be above 0. Don't be afraid to be proven wrong. That's where some of the highest quality deductions and reason come from.

Conclusion

this article is not intended to convince you to get into AI. it is also not intended to rehabilitate the image of AI. all it is, is an exploration on how I started using AI, and how I've managed to find it useful while minimizing the pain points.

AI isn't perfect, and I hope this article made it extremely clear that you need to verify and make sure what you're reading is correct. Infact, this skill isn't really limited to AI either - it applies to everyone. Think of all the cult leaders and propaganda. They existed long before the age of AI - and the same limits that help you break free of those shackles to process the truth and be able to iterate upon it, are the same limits that help you when working with AI. The only difference is that AI isn't actively malicious or predatory. It is an agent that doesn't know exactly what it is doing, and simply has a complex network of "neurons" that interface with each other inside a black box, in order to produce an output that it is carefully tuned for.

if this article convinces you to give it a shot however, i'd like to make a suggestion. look into local models first. they're getting pretty good, aren't that hard to setup, and you basically avoid all cost, except for the very slight bump in the electricity bill. if you have the money and want to shell out for something more higher end however, definitely avoid basically all American AI - because not only are its prices rising considerably due to basically having faked what the cost was, but they also have the wrong motivations and are actively making the lives of Americans worse, what with all the data centers and hijacking of the government.

i can't recommend what to go with - however i personally use Deepseek 4 Flash with the Pi Agent. if you worry about data sovereignty, then that applies to every single remote model, except for the very rare cases where the company is privacy-focused and has been proven to be trustworthy over years. yes, I'm basically referring to Proton here. if you're worried about Chinese access to your data, then my question to you is "Why does it matter if China has my data instead of the US or Europe?" - and im not saying data sovereignty isn't worth worrying about, but don't fall for all the geopolitical theater, because it tends to get weaponized.

especially for example, with Deepseek, which is actively threatening the business models of American AI by being so much cheaper and open source. keep that in mind, you can use Deepseek from a different provider if that is your major concern.

to me, Deepseek 4 Flash at max reasoning is not only extremely good, but also pretty cheap, especially when compared to other models. you might roll your eyes, but I do mean cheap -- I topped up with 10usd 2.5 weeks ago (yes I use euro, but they accept USD or the Yuan only), expecting to run out in a couple of days, and instead I currently still have $1.43 left. and i have been using it quite extensively across my projects too - with no regrets. because I have both learned far more, and accomplished far more, than I would have in months without it.

plus they care about the actual efficiency of the model, so it literally consumes significantly less power than the american variants which just throw more data centers at the problem.

as for the Pi agent - an agent basically empowers the model you use with tools, such as being able to read and write files. the Pi agent is a very minimal version that only provides the most basic utilities, and an extension system. its main attraction is the fact that you can use Pi to extend itself - which I have done to pretty great effect actually. it's actually a good proof of concept - you don't get any bonuses for free, but the process of adding bonuses is fun, effective, and functional. And if you run into issues, also educational.

anyways. this has been my very long article about AI that im not sure anyone will read - but I've been thinking a lot and had to put it down somewhere. it felt useful to share the perspective of someone using and benefitting from AI, from the perspective of someone who isn't an insufferable tech bro, and is instead someone who used to very strongly think that this technology is either useless, or too expensive.

i hope that at the very least this was an interesting read.