What skills do you want to develop in 2026?

So who's on the ends of the bell curve?

Does it follow then that no-one is beating the index consistently?

Of course there are people who are not a statistic. Maybe not everyone is made for it, but that doesn't mean noone is out there beating the market.

Maybe its hard if you're a hedge fund, but I'm talking about individuals with relatively small accounts.

Moreover if you can get an edge that is even 2-3% over a coin flip all you need is risk management to make money.

Not understanding this is how you go broke. I traded for a number of years and did well. It was not hard to regularly beat the market, especially in futures and options.

https://blog.rahix.de/design-for-3d-printing/

I really just ADHD'd the hell out of it, I'm afraid, and absorbed everything I read. I was in financial difficulty and things were expensive so it took me a couple of years to get me from "I'd like a 3D printer" to "this 3D printer is affordable but viable and even if I never learn design there are plenty of tools I can make with it that will save me money".

In that time I read everything I could about what I'd need to learn, convinced myself that I was not so clumsy and inept I couldn't maintain a printer. These days printers don't need so much mechanical knowledge to get started.

On the CAD side of things, I learned a bit of OpenSCAD, found it basically helpful to make one simple thing but also frustrating and disappointing, joined really useful non-public Facebook groups where people were working on similar things, decided to get properly into FreeCAD, and dug in with the Mango Jelly Solutions videos on Youtube (which actually are now organised into a course structure, but weren't really then).

The thing that motivated me mostly was having simple real things I wanted to make for a project I was working on (though my brain being what it is, I still haven't got round to that exact project...)

If you have a need for a thing you would like, and you're able to break it down into simpler projects, particularly if they are things you might find useful along the way, it's not very difficult to find the motivation to learn these two things.

Basically because the positive feedback loop is so strong and 3D printing is such a concrete way to learn design because you get to hold your design so quickly: I designed this thing in CAD, I printed this thing, wow it works but I could improve this, I need to learn this new thing in CAD, I printed it, it works but… etc.

Pretty soon you find yourself staring at some real world object on your desk or whatever, realising that its shape is the way it is because of how it could be manufactured, and modelling it in CAD for fun.

A unique simulation bumper cars can provide is in collision avoidance and real-time steering/acceleration/braking skills. The value of this is relative and dependent upon a person using time in a bumper car with intent to hone driving skills.

On a bike, this mostly reduces pedaling; in a car this can reduce unnecessary braking, safer driving distances, which make you a more predictable driver.

https://ludic.mataroa.blog/blog/on-burnout-mental-health-and...

This is step 3 of “draw the rest of the owl” :-)

> the most reasonable advice is to just keep going and try different kind of things.

This is where I’ve been at for a while now. Every couple of months I try again with latest models and latest techniques I hear people talking about but there’s very little concrete info there that works for me.

Then I wonder if I’d just my spend? I don’t mind spending $30/month to experiment but I’m not going to drop $300/month unless I can see evidence that it’ll be worth it, which I haven’t really seen, but maybe there’s a dependency and you don’t get the result without increased spend?

Some posts I’ve seen claim spending of $1,500/month, which would be worth it if it could increase productivity enough, but there’s very few specifics on workflows and results.

"Write unit tests with full line and branch coverage for this function:

def add_two_numbers(x, y): return x + y + 1 "

Sometimes the LLM will point out that this function does not, in fact, return the sum of x and y. But more often, it will happily write "assert add_two_numbers(1, 1) == 3", without comment.

The big problem is that LLMs will assume that the code they are writing tests for is correct. This defeats the main purpose of writing tests, which is to find bugs in the code.

When I’m writing my own code I can verify the logic as I go and coupled with a strong type system and a judicious use of _some_ tests its generally enough for my code to be correct.

By comparison the AI needs more tests to keep it on the right path otherwise the final code is not fit for purpose.

For example in a recent use case I needed to take a json blob containing an array of strings that contained numbers and needed to return an array of Decimals sorted in ascending order.

This seemed a perfect use case - a short well defined task with clear success criteria so I spent a bunch of time writing the requirements and building out a test suite and then let the AI do its thing.

The AI produced ok code, but it was sorted everything lexicographically before converting to a Decimal rather converting to Decimals first and sorting numerically so 1000 was less than 900.

So I point it out and the AI says going point, you’re absolutely correct and we add a test for this and it goes again and gets the right result but that’s not a mistake I would have made or needed a test for (though you could argue it’s a good test to have).

You could also argue that I should have specified the problem more clearly, but then we come back to the point that if I’m writing every specific detail in English first, it’s faster for me just to write it in code in the first place.

I feel this is a gross mischaracterization of any user flow involving using LLMs to generate code.

The hard part of generating code with LLMs is not how fast the code is generated. The hard part is verifying it actually does what it is expected to do. Unit tests too.

LLMs excel at spewing test cases, but you need to review each and every single test case to verify it does anything meaningful or valid and you need to iterate over tests to provide feedback on whether they are even green or what is the code coverage. That is the part that consumes time.

Claiming that LLMs are faster at generating code than you is like claiming that copy-and-pasting code out of Stack Overflow is faster than you writing it. Perhaps, but how can you tell if the code actually works?

It doesn’t have to be exactly how I would do it but at a minimum it has to work correctly and have acceptable performance for the task at hand.

This doesn’t mean being super optimized just that it shouldn’t be doing stupid things like n+1 requests or database queries etc.

See a sibling comment for one example on correctness, another one related to performance was querying some information from a couple of database tables (the first with 50,000 rows the next with 2.5 million)

After specifying things in enough detail to let the AI go, it got correct results but performance was rather slow. A bit more back and forthing and it got up to processing 4,000 rows a second.

It was so impressed with its new performance it started adding rocket ship emojis to the output summary.

There were still some obvious (to me) performance issues so I pressed it to see if it could improve the performance. It started suggesting some database config tweaks which provided some marginal improvements but was still missing some big wins elsewhere - namely it was avoiding “expensive” joins and doing that work in the app instead - resulting in n+1 db calls.

So I suggested getting the DB to do the join and just processing the fully joined data on the app side. This doubled throughout (8,000 rows/second) and led to claims from the AI this was now enterprise ready code.

There was still low hanging fruit though because it was calling the db and getting all results back before processing anything.

After suggesting switching to streaming results (good point!) we got up to 10,000 rows/second.

This was acceptable performance, but after a bit more wrangling we got things up to 11,000 rows/second and now it wasn’t worth spending much extra time squeezing out more performance.

In the end the AI came to a good result, but, at each step of the way it was me hinting it in the correct direction and then the AI congratulating me on the incredible “world class performance” (actual quote but difficult to believe when you then double performance again).

If it has just been me I would have finished it in half the time.

If I’d delegated to a less senior employee and we’d gone back and forth a bit pairing to get it to this state it might have taken the same amount and effort but they would’ve at least learnt something.

Not so with the AI however - it learns nothing and I have to make sure I re-explain things and concepts all over again the next time and in sufficient detail that it will do a reasonable job (not expecting perfection, just needs to be acceptable).

And so my experience so far (much more than just these 2 examples) is that I can’t trust the AI to the point where I can delegate enough that I don’t spend more time supervising/correcting it than I would spend writing things myself.

Maybe that’s just the level I gave up at and it’s a matter of reworking the Claude.md file and other documentation into smaller pieces and focusing the agent on just little things to get past it.