[HN Gopher] Thesis: Interesting work is less amenable to the use...
___________________________________________________________________
Thesis: Interesting work is less amenable to the use of AI
Author : koch
Score : 133 points
Date : 2025-07-06 21:01 UTC (1 days ago)
(HTM) web link (remark.ing)
(TXT) w3m dump (remark.ing)
| bitwize wrote:
| But... agentic changes everything!
| aleph_minus_one wrote:
| ... for the worse. :-)
| CuriouslyC wrote:
| I remember I thought cars were pretty shit when I didn't know
| how to drive.
| aaronbrethorst wrote:
| The vast majority of any interesting project is boilerplate.
| There's a small kernel of interesting 'business logic'/novel
| algorithm/whatever buried in a sea of CRUD: user account
| creation, subscription management, password resets, sending
| emails, whatever.
| forrestthewoods wrote:
| This depends entirely on the type of programming you do. If all
| you build is CRUD apps then sure. Personally I've never
| actually made any of those things -- with or without AI
| PeterStuer wrote:
| You are both right. B2B for instance is mostly fairly
| template stuff built from CRUD and some business rules. Even
| some of the more perceived as 'creative' niches such as music
| scoring or 3D games are fairly route interactions with some
| 'engine'.
|
| And I'm not even sure these 'template adjacent'
| regurgitations are what the crude LLM is best at, as the
| output needs to pass some rigorous inflexible test to 'pass'.
| Hallucinating some non-existing function in an API will be a
| hard fail.
|
| LLM's have a far easier time in domains where failures are
| 'soft'. This is why 'Elisa' passed as a therapist in the
| 60's, long before auto-programmers were a thing.
|
| Also, in 'academic' research, LLM use has reached nearly
| 100%, not just for embelishing writeups to the expected 20
| pages, but in each stage of the'game' including 'ideation'.
|
| And if as a CIO you believe that your prohibition on using
| LLMs for coding because of 'divulging company secrets' holds,
| you are either strip searching your employees on the way in
| and out, or wilfully blind.
|
| I'm not saing 'nobody' exists that is not using AI in
| anything created on a computer, just like some woodworker
| still handcrafts exclusive bespoke furniture in a time of
| presses, glue and CNC, but adoption is skyrocketing and not
| just because the C-suite pressures their serves into using
| the shiny new toy.
| rijoja wrote:
| > "And if as a CIO you believe that your prohibition on
| using LLMs for coding because of 'divulging company
| secrets' holds, you are either strip searching your
| employees on the way in and out, or wilfully blind."
|
| Right so if you are in certain areas you'll be legally
| required not to send your work to whatever 3:rd party that
| promises to handle it the cheapest.
|
| Also so since this is about actually "interesting" work if
| you are doing cutting edge research on lets say military or
| medical applications** you definitely should take things
| like this seriously.
|
| Obviously you can do LLM's locally if you don't feel like
| paying up for programmers who likes to code, and who wants
| to have in-depth knowledge of whatever they are doing.
|
| ** https://www.bbc.co.uk/news/articles/c2eeg9gygyno
| PeterStuer wrote:
| Of course you should not violate company policy, and some
| environments will indeed have more stringent controls and
| measures, but there is a whole world of grey were the CIO
| has put in place a moratorium on LLM but where some
| people will quickly crunch out the day's work at home
| with an AI anyways so they look more productive.
| rijoja wrote:
| You can of course run consider running your own LLM.
|
| I suppose the problem isn't really the technology itself
| but rather the quality of the employees. There would've
| been a lot of people cheating the system before, lets say
| just by copy pasting or tricking your coworkers into
| doing the work for you.
|
| However if you are working with something actually
| interesting, chances are that you're not working with
| disingenuous grifters and uneducated and lazy
| backstabbers, so that's less of a concern as well. If you
| are working on interesting projects hopefully these
| people would've been filtered out somewhere along the
| line.
| bravesoul2 wrote:
| Most places I worked the setting up of that kind of boilerplate
| was done a long time ago. Yes it needs maintaining and
| extending. But rarely building from the ground up.
| rijoja wrote:
| Yes so why would you spend tons of time and introduce a huge
| amount of technical debt by rewriting the boring parts, instead
| of just using a ready made off the shelf solution in that case.
|
| You'd think that there be someone who'd be nice enough to
| create a library or a framework or something that's well
| documented and is popular enough to get support and updates.
| Maybe you should consider offloading the boring part to such a
| project, maybe even pay someone to do it?
| oc1 wrote:
| That was a solved problem in the 00's with the advent of
| Rails, or so i thought. Then came the JS framework craze and
| everything needed to be reinvented. Not just that, but
| frameworks which had all these battle-tested boring parts
| were not trendy anymore. Micro framworks became the new
| default and idiots after idiots jumped on that bandwagon only
| to reimplement everything from scratch because almost any app
| will grow to a point where it will need authn, user mgmt,
| mail, groups and so on...
| ianbicking wrote:
| There's a hundred ways to use AI for any given work. For example
| if you are doing interesting work and aren't using AI-assisted
| research tools (e.g., OpenAI Deep Research) then you are missing
| out on making the work that more interesting by understanding the
| context and history of the subject or adjacent subjects.
|
| This thesis only makes sense if the work is somehow interesting
| and you also have no desire to extend, expand, or enrich the
| work. That's not a plausible position.
| wolvesechoes wrote:
| > This thesis only makes sense if the work is somehow
| interesting and you also have no desire to extend, expand, or
| enrich the work. That's not a plausible position.
|
| Or your interesting work wasn't appearing in training set often
| enough. Currently I am writing a compiler and runtime for some
| niche modeling language, and every model I poke for help was
| rather useless except some obvious things I already know.
| ianbicking wrote:
| Some things you could do:
|
| 1. Look up compiler research in relevant areas
|
| 2. Investigate different parsing or compilation strategies
|
| 3. Describe enough of the language to produce or expand test
| cases
|
| 4. Use the AI to create tools to visualize or understand the
| domain or compiler output
|
| 5. Discuss architectural approaches with the AI (this might
| be like rubber duck architecting, but I find that helpful
| just like rubber duck debugging is helpful)
|
| The more core or essential a piece of code is, the less
| likely I am to lean on AI to produce that piece of code. But
| that's just one use of AI.
| voxelghost wrote:
| I don't have LLM/AI write or generate any code or document for
| me. Partly because the quality is not good enough, and partly I
| worry about copyright/licensing/academic rigor, partly because I
| worry about losing my own edge.
|
| But I do use LLM/AI, as a rubber duck that talks back, as a
| google on steroids - but one who needs his work double checked.
| And as domain discovery tool when quickly trying to get a grasp
| of a new area.
|
| Its just another tool in the toolbox for me. But the toolbox is
| like a box of chocolates - you never know what you are going to
| get.
| CuriouslyC wrote:
| In the new world that's emerging, you are losing your edge by
| not learning how to master and leverage AI agents. Quality not
| good enough? Instruct them in how you want them to code, and
| make sure a sufficient quantity of the codebase is loaded into
| their context so they can see examples of what you consider
| good enough.
| towledev wrote:
| >Instruct them in how you want them to code
|
| They don't always listen.
|
| Writing SQL, I'll give ChatGPT the schema for 5 different
| tables. It habitually generates solutions with columns that
| don't exist. So, naturally, I append, "By the way, TableA has
| no column FieldB." Then it just imagines a different one. Or,
| I'll say, "Do not generate a solution with any table-col pair
| not provided above." It doesn't listen to that at all.
| CuriouslyC wrote:
| I haven't had that problem with Gemini 2.5 pro or O3, are
| you on the free tier of ChatGPT?
| ofjcihen wrote:
| You do understand that these models are not sentient and
| are subject to hundreds of internal prompts, weights, and
| a training set right?
|
| They can't generate knowledge that isn't in their corpus
| and the act of prompting (yes, even with agents ffs) is
| more akin to playing pachinko than it is pool?
| ofjcihen wrote:
| This is something that people working on extremely simple
| apps don't understand because for their purposes it looks
| like magic.
|
| If you know what you're doing and you're trying to achieve
| something other than the same tutorials that have been
| pasted all over the internet the non-deterministic pattern
| machine is going to generate plausible bs.
|
| They'll tell you any number of things that you're
| supposedly doing wrong without understanding what the
| machine is actually doing under the hood.
| janaagaard wrote:
| A Danish audio newspaper host / podcaster had the exact apposite
| conclusion when he used ChatGPT to write the manuscript for one
| his episodes. He ended up spending as much time as he usually
| does because he had to fact check everything that the LLM came up
| with. Spoiler: It made up a lot of stuff despite it being very
| clear in the prompt, that it should not do so. To him, it was the
| most fun part, that is writing the manuscript, that the chatbot
| could help him with. His conclusion about artificial intelligence
| was this:
|
| "We thought we were getting an accountant, but we got a poet."
|
| Frederik Kulager: Jeg fik ChatGPT til at skrive dette afsnit, og
| testede, om min chefredaktor ville opdage det.
| https://open.spotify.com/episode/22HBze1k55lFnnsLtRlEu1?si=h...
| rijoja wrote:
| It's not the exact opposite*, the author said that if you're
| doing boilerplate _code_ it's probably fine.
|
| The thing is that since it can't think, it's absolutely useless
| when it comes to things that hasn't been done before, because
| if you are creating something new, the software won't have had
| any chance to train on what you are doing.
|
| So if you are in a situation in which it is a good idea to
| create a new DSL for your problem **, then the autocruise
| control magic won't work because it's a new language.
|
| Now if you're just mashing out propaganda like some brainwashed
| soviet apparatchik propagandist, maybe it helps. So maybe
| people who writes predictable slop like this the guardian
| article (https://archive.is/6hrKo) would be really grateful
| that their computer has a cruise control for their political
| spam.
|
| _) if that 's what you meant *_) which you statistically
| speaking might not want to do, but this is about actually
| interesting work where it's more likely to happen*
| CuriouslyC wrote:
| In a world where the AI can understand your function library
| near flawlessly and compose it in to all sorts of things, why
| would you put the effort into a DSL that humans will have to
| learn and the AI will trip over? This is a dead pattern.
| ofjcihen wrote:
| This is completely ignoring the purpose of a DSL.
|
| Dead pattern? Really?
| marssaxman wrote:
| It's a big leap from that hypothetical world back to ours.
| snapcaster wrote:
| Maybe reconsider assumptions? Maybe DSLs shouldn't be done
| anymore if they're not able to be utilized by AI agents
| easily
| notachatbot123 wrote:
| > It made up a lot of stuff despite it being very clear in the
| prompt, that it should not do so.
|
| LLMs are not sentient. They are _designed_ to make stuff up
| based on probability.
| NetRunnerSu wrote:
| Unfortunately, they could have been thinking, but the
| designation of the training/inference separation made them
| all specimens.
|
| https://news.ycombinator.com/item?id=44488126
| odyssey7 wrote:
| I love this turn of phrase. It quite nicely evokes the
| difference between how the reader thinks vs how the LLM does.
|
| It also invites reflections on what "sentience" means. In my
| experience -- make of it what you will -- correct fact
| retrieval isn't really necessary or sufficient for there to
| be a lived, first-person experience.
| lxgr wrote:
| Why would sentience be required for logically sound reasoning
| (or the reverse, for that matter)?
| satisfice wrote:
| As a writer I find his take appalling and incomprehensible. So,
| apparently not all writers agree that writing with AI is fun.
| To me, it's a sickening violation of integrity.
| CuriouslyC wrote:
| It's all fine as long as you keep that fetish in your
| dungeon.
| pickledoyster wrote:
| Yeah, if I were their reader, I'd most likely never read
| anything from them again, since nothing's stopping them from
| doing away with integrity altogether and just stitching
| together a bunch of scripts ('agents') into an LLM slop
| pipeline.
|
| It's so weird how people use LLMs to automate the most
| important and rewarding parts of the creative process. I get
| that companies have no clue how to market the things, but it
| really shows a lack of imagination and self-awareness when a
| 'creative' repackages slop for their audience and calls it
| 'fun'.
| darkxanthos wrote:
| It's definitely real that a lot of smart productive people don't
| get good results when they use AI to write software.
|
| It's also definitely real that a lot of other smart productive
| people are more productive when they use it.
|
| These sort of articles and comments here seem to be saying I'm
| proof it can't be done. When really there's enough proof it can
| be that you're just proving you'll be left behind.
| bertman wrote:
| >you're just proving you'll be left behind.
|
| ... said every grifter ever since the beginning of time.
| rijoja wrote:
| yes
| viccis wrote:
| The one thing AI is good at is building greenfield projects from
| scratch using established tools. If want you want to accomplish
| can be done by a moderately capable coder with some time reading
| the documentation for the various frameworks involved, then I
| view AI as fairly similar to the scaffolding that happened with
| Ruby on Rails back in the day when I typed "rails new myproject".
|
| So LLMs are awesome if I want to say "create a dashboard in
| Next.js and whatever visualization library you think is
| appropriate that will hit these endpoints [dumping some API specs
| in there] and display the results to a non-technical user", along
| with some other context here and there, and get a working first
| pass to hack on.
|
| When they are not awesome is if I am working on adding a map
| visualization to that dashboard a year or two later, and then I
| need to talk to the team that handles some of the API endpoints
| to discuss how to feed me the map data. Then I need to figure out
| how to handle large map pin datasets. Oh, and the map shows
| regions of activity that were clustered with DBSCAN, so I need to
| know that Alpha shape will provide a generalization of a convex
| hull that will allow me to perfectly visualize the cluster
| regions from DBSCAN's epsilon parameter with the corresponding
| choice of alpha parameter. Etc, etc, etc.
|
| I very rarely write code for greenfield projects these days,
| sadly. I can see how startup founders are head over heels over
| this stuff because that's what their founding engineers are
| doing, and LLMs let them get it cranking very very fast. You just
| have to hope that they are prudent enough to review and tweak
| what's written so that you're not saddled with tech debt. And
| when inevitable tech debt needs paying (or working around) later,
| you have to hope that said founders aren't forcing their
| engineers to keep using LLMs for decisions that could cut across
| many different teams and systems.
| mattmanser wrote:
| I get what point you're trying to make, and agree, but you've
| picked a bad example.
|
| That boilerplate heavy, skill-less, frontend stuff like
| configuring a map control with something like react-leaflet
| seems to be precisely what AI is good at.
| viccis wrote:
| Yeah it will make a map and plot some stuff on it. It might
| do well at handling 20 millions pins on the map gracefully
| even. I doubt it's gonna know to use alpha shapes to
| complement DBSCAN quite so gracefully.
|
| edit: Just spot checked it and it thinks it's a good idea to
| use convex hulls.
| JimDabell wrote:
| If AI can do the easiest 50% of our tasks, then it means we will
| end up spending all of our time on what we previously considered
| to be the most difficult 50% of tasks. This has a lot of
| implications, but it does generally result in the job being more
| interesting overall.
| mhuffman wrote:
| >This has a lot of implications, but it does generally result
| in the job being more interesting overall.
|
| One implication is that when AI providers claim that "AI can
| make a person TWICE as productive!"
|
| ... business owners seem to be hearing that as "Those users
| should cost me HALF as much!"
| KronisLV wrote:
| > we will end up spending all of our time on what we previously
| considered to be the most difficult 50% of tasks
|
| Either that, or replacing the time with slacking off and not
| even getting whatever benefits doing the easiest tasks might
| have had (learning, the feeling of accomplishing something),
| like what some teachers see with writing essays in schools and
| homework.
|
| The tech has the potential to let us do less busywork (which is
| great, even regular codegen for boilerplate and ORM mappings
| etc. can save time), it's just that it might take conscious
| effort not to be lazy with this freed up time.
| JimDabell wrote:
| The industry has already gone through many, many examples of
| software reducing developer effort. It always results in
| developers becoming more productive.
| tjpnz wrote:
| You'll potentially be building on flimsy foundations if it gets
| the foundational stuff wrong (see anecdote in sibling post). I
| fear for those who aren't so diligent, especially if there are
| consequences involved.
| CuriouslyC wrote:
| The strategy is to have it write tests, and spend your time
| making sure the tests are really comprehensive and correct,
| then mostly just trust the code. If stuff breaks down the
| line, add regression tests, fix the problem and continue with
| your day.
| danaris wrote:
| > If AI can do the easiest 50% of our tasks
|
| ...But it can't, which means your inference has no
| implications, because it evaluates to False.
| harimau777 wrote:
| In my experience, the 50% most difficult part of a problem is
| often the most boring. E.g. writing tests, tracking down
| obscure bugs, trying to understand API or library
| documentation, etc. It's often stuff that is very difficult but
| doesn't take all that much creativity.
| JimDabell wrote:
| I disagree with all of those. Tracking down obscure bugs is
| interesting, and all the other examples are easy.
| pickledoyster wrote:
| Or, alternatively, the difficult 50% are difficult because
| they're uninteresting, like trying to find an obscure
| workaround for an unfixed bug in excel, or re-authing for the
| n-th time today, or updating a Jira ticket, or getting the only
| person with access to a database to send you a dataset when
| they never as much as reply to your emails...
| seydor wrote:
| I am 100% sure that horse-breeders and carriage-decorators also
| had very high interest in their work and craft.
| keiferski wrote:
| I have gotten much more value out of AI tools by focusing on the
| process and not the product. By this I mean that I treat it as a
| loosely-defined brainstorming tool that expands my "zone of
| knowledge", and not as a way to create some particular thing.
|
| In this way, I am infinitely more tolerant of minor problems in
| the output, because I'm not using the tool to create a specific
| output, I'm using it to enhance the thing I'm making myself.
|
| To be more concrete: let's say I'm writing a book about a novel
| philosophical concept. I don't use the AI to actually write the
| book itself, but to research thinkers/works that are similar,
| critique my arguments, make suggestions on topics to cover, etc.
| It functions more as a researcher and editor, not a writer - and
| in that sense it is extremely useful.
| zeroto100 wrote:
| Agree - I tend to think of it as offloading thinking time.
| Delegating work to an agent just becomes more work for me, with
| the quality I've seen. But conversations where I control the
| context are both fun and generally insightful, even if I decide
| the initial idea isn't a good one.
| keiferski wrote:
| That is a good metaphor. I frequently use ChatGPT in a way
| that basically boils down to: I could spend an hour thinking
| about and researching X basic thing I know little about, or I
| could have the AI write me a summary that is 95% good enough
| but only takes a few seconds of my time.
| hombre_fatal wrote:
| I think it's a U-shaped utility curve where abstract planning
| is on one side (your comment) and the chore implementation is
| on the other.
|
| Your role is between the two: deciding on the architecture,
| writing the top-level types, deciding on the concrete system
| design.
|
| And then AI tools help you zoom in and glue things together in
| an easily verifiable way.
|
| I suspect that people who still haven't figured out how to make
| use of LLMs, assuming it's not just resentful performative
| complaining which it probably is, are expecting it to do it
| all. Which never seemed very engineer-minded.
| Q6T46nT668w6i3m wrote:
| You don't empathize with the humane opinion "why bother?" I
| like to program so it resonates. I'm fortunate to enjoy my
| work so why would I want to stop doing what I enjoy?
| hombre_fatal wrote:
| Sure, don't use if you don't want to. I'm referring to
| versions of the claim I see around here like LLMs are
| useless. Being so uncurious as to refuse to figure out what
| a tool might be useful for is an anti-engineering mindset.
|
| Just like you should be able to say something positive
| about Javascript (async-everything instead of a bolted-on
| async subecosystem, event loop has its upsides, single-
| threaded has its upsides, has a first class promise, etc)
| even if you don't like using it.
| ofjcihen wrote:
| As a counter argument, the replies I see that say LLMs
| are "useless" are saying they're useless to the person
| attempting to use them.
|
| This can be a perfectly valid argument for many reasons.
| Their use case isn't well documented, can't be publicly
| disclosed, involves APIs that aren't public, or are
| actual research and not summarizing printed research to
| name a few I've run into myself.
|
| This argument that "engineers are boring and afraid for
| their jobs" is ignoring the fact that these are usually
| professionals with years of experience in their fields
| and probably perfectly able to assess the usefulness of a
| tool for their purposes.
| exe34 wrote:
| > easily verifiable way
|
| _willy wonka _oh really_ meme_
| paulcole wrote:
| Thesis: Using the word "thesis" is a great way to disguise a
| whiny op-ed as the writings of a learned soul
|
| > interesting work (i.e., work worth doing)
|
| Let me guess, the work you do is interesting work (i.e., work
| worth doing) and the work other people do is uninteresting work
| (i.e., work not worth doing).
|
| Funny how that always happens!
| simpaticoder wrote:
| Yes, asking an LLM to "think outside the box" won't work. It _is_
| the box.
| briandw wrote:
| I feel much more confident that I can take on a project in a
| domain that im not very familiar with. Ive been digging into llvm
| ir and I had not prior experience with it. ChatGPT is a much
| better guide to getting started than the documentation, which is
| very low quality.
| loloquwowndueo wrote:
| Careful - if you're not familiar with the domain how are you
| going to spot when the LLM gives you suboptimal or even
| outright wrong answers?
| sealeck wrote:
| Testing
| briandw wrote:
| Just like anything else, stackoverflow, advice from a
| coworker or expert. If it doesn't work, it will become clear
| that it's not fixing your problem.
| loloquwowndueo wrote:
| If all you're doing is ping-ponging back and forth between
| an expert and an LLM, then what's your value ?
| briandw wrote:
| Don't think what I described was ping-ponging. But if you
| want to see it that way, go ahead.
|
| To clarify my process. 1) I have a problem in a new
| domain that I'm stuck on. 2) I work with the LLM to
| discuss my problem, think about solutions, get things to
| try. Not unlike StackOverflow or digging through
| documentation. However this process is much faster and I
| learn more without being called stupid by random people
| on SO (or HN). 3) The problem is fixed and I move on, or
| back to 1 or try something else.
|
| The value here is that I have a problem to solve and I'm
| seeing it through to the end. I know what good looks like
| and have the agency and attention span to get there. The
| LLM doesn't and likely won't for quite some time.
| javcasas wrote:
| Good luck with that.
|
| I have been exploring local AI tools for coding (ollama +
| aider) with a small stock market simulator (~200 lines of
| python).
|
| First I tried making the AI extract the dataclasses
| representing events to a separated file. It decided to extract
| some extra classes, leave behind some others, and delete parts
| of the code.
|
| Then I tried to make it explain one of the actors called
| LongVol_player_v1, around 15 lines of code. It successfully
| concluded it does options delta hedging, but it jumped to the
| conclusion that it calculates the implied volatility. I set it
| as a constant, because I'm simulating specific interactions
| between volatility players and option dealers. It hasn't caught
| yet the bug where the vol player buys 3000 options but accounts
| only for 2000.
|
| When asking for improvements, it is obsessed with splitting the
| initialization and the execution.
|
| So far I wasted half of Saturday trying to make the machine do
| simple refactors. Refactors I could do myself in half of an
| hour.
|
| I'm yet to see the wonders of AI.
| kenjackson wrote:
| Could you link the repo and prompts? What you described seems
| like the type of thing I've done before with no issue so you
| may have an interesting code base that is presenting some
| issues for the LM.
| javcasas wrote:
| I cannot post the link to the repo, as it contains
| sensitive stuff. The code is mostly a bunch of classes with
| interleaved dataclasses, and a bunch of main() and run()
| functions at the end.
|
| Some of the logs: #### /add main.py
| > Added main.py to the chat #### Please describe
| what the project does. The project appears to be
| a simulation of stock market behavior using various actors
| and models. The main components are: 1.
| `Simulator` class: This is the core of the system. It
| manages events by maintaining a queue of pending events,
| processes them sequentially, and delegates processing to
| other classes like Market_v1 or Dealer_v1 based on event
| type. // Wrong, all the classes receive all the events,
| and they decide which events they act upon. There is no
| 'based on event type'. 2. `Market_v1` class:
| This represents the stock market. It updates its price
| based on trades made (represented by `MarketOrder` events),
| and submits a new quote every time its price changes.
| 3. `Dealer_v1` class: This is an actor that manages options
| positions. It hedges its portfolio against price movements
| in the stock market, and updates its position based on
| option trades made (represented by `MarketOrder` events).
| 4. Other classes like `Logger` or `OHLCLogger` are used to
| process different types of events: they log messages for
| debugging purposes, or generate OHLC bars representing a
| period of time with the highest and lowest prices.
| 5. There are also various players that simulate market
| behavior: ShortVol_player_v1 and LongVol_player_v1 make
| trades based on short-term volatility and long-term
| volatility respectively. // Wrong, ShortVol and LongVol
| are focused on shorting/buying volatility, not short/long
| term. 6. The `run` function is the entry point
| of the program, which sets up actors and events to simulate
| a period of time. It returns the final stock market price.
| Please let me know if you need any changes or further
| explanations about this project. > Tokens: 3.7k
| sent, 299 received. #### How does the
| LongVol_player_v1 know the volatility? The
| `LongVol_player_v1` class doesn't directly know the
| volatility (sigma) of the underlying stock. Instead, it
| interacts with the `Dealer_v1` class to make trades based
| on implied volatility. When an option contract
| is traded, a `MarketOrder` event is submitted by the
| `LongVol_player_v1`. This event includes information about
| the type of trade (buy or sell), the strike price and
| expiration date of the option, as well as the amount of
| contracts to be bought or sold. The `Dealer_v1`
| class processes this event by updating its options
| portfolio and recalculating the delta hedge. The volatility
| is used in these calculations when it's passed into the
| `BlackScholesPricingModel` constructor, which calculates
| various option metrics like delta, gamma, vega etc., based
| on the supplied parameters (risk free rate, spot price,
| strike price, time to expiration and implied volatility).
| So in summary, the `LongVol_player_v1` doesn't know the
| actual underlying stock's volatility. Instead, it knows how
| to make trades based on implied volatilities derived from
| option contracts. The `Dealer_v1` class is responsible for
| keeping track of these implied volatilities and
| recalculating the delta hedge whenever an option trade
| occurs. // Wrong: implied volatility is set as a constant
| to 70. No tracking. > Tokens: 4.0k sent, 262
| received.
|
| ----------------------------------- >
| /home/javier/.local/bin/aider --model
| ollama_chat/qwen2.5-coder:3b > Aider v0.85.1
| > Model: ollama_chat/qwen2.5-coder:3b with whole edit
| format > Git repo: .git with 2 files >
| Repo-map: using 4096.0 tokens, auto refresh ####
| /add ma > No files matched 'ma'. Do you want to
| create /home/javier/proyectos/algo-trading/dealer-sim/ma?
| (Y)es/(N)o [Yes]: n #### /add main.py >
| Added main.py to the chat #### /add events.py
| > Added events.py to the chat #### Please
| extract the Stock and Option classes from `main.py` to
| `events.py`. To extract the `Stock` and `Option`
| classes from `main.py` to `events.py`, I will create a new
| file named `events.py` and move the class definitions
| there. Here is the updated content: events.py
| ``` import typing @dataclass class
| Stock: pass
| @dataclass(unsafe_hash=True) class Option:
| strike: int type:
| typing.Union[typing.Literal['c'], typing.Literal['p']]
| expiration: int ``` main.py ```
| import queue from dataclasses import dataclass
| import events # Import the new events module import
| random import typing import math
| #random.seed(2) @dataclass class
| MarketOrder: amount: int asset:
| typing.Union[events.Stock, events.Option]
| @dataclass class Quote: price: float
| @dataclass class TimeElapsed: current_time:
| float class Simulator: # details
| omitted # No more code. All other classes and
| functions were removed. ``` This change
| moves the `Stock` and `Option` classes from `main.py` to
| `events.py`, ensuring that they are organized separately
| and can be reused across different parts of the application
| if needed. > Tokens: 3.6k sent, 350 received.
| #### Please restore the Market_v1, Dealer_v1 and
| Market_chaos_v1 classes back to main.py. To
| restore the `Market_v1`, `Dealer_v1`, and `Market_chaos_v1`
| classes to `main.py`, I will add them back. Here is the
| updated content for `main.py`: main.py ```
| import queue from dataclasses import dataclass
| import events # Import the new events module import
| random import typing import math
| #random.seed(2) @dataclass class
| Market_v1: pass # Funny AI, where is the code?
| @dataclass class Dealer_v1: pass # Funny
| AI, where is the code? @dataclass class
| Market_chaos_v1: pass # Funny AI, where is the
| code? @dataclass class MarketOrder:
| amount: int asset: typing.Union[events.Stock,
| events.Option] @dataclass class Quote:
| price: float @dataclass class TimeElapsed:
| current_time: float class Simulator: #
| omitted from logs ``` This change restores
| the `Market_v1`, `Dealer_v1`, and `Market_chaos_v1` classes
| to their original locations in `main.py`. >
| Tokens: 2.8k sent, 318 received. > Applied edit to
| main.py
| javcasas wrote:
| More logs: #### /ask What would you
| refactor from main.py? #### What would you
| refactor from main.py? Based on the provided
| `main.py` file, here are some potential areas for
| refactoring: 1. \*Separation of Concerns\*:
| The `run()` function is responsible for initializing the
| simulation and running it. This could be separated into
| two functions: one for initialization
| (`init_simulation()`) and another for running the
| simulation (`run_simulation()`). 2. \*Code
| Duplication\*: There are several places where similar
| code is repeated, such as in the `Market_v1` and
| `Market_chaos_v1` classes. These can be refactored into a
| single class or function. // LOL no, these two classes
| exist for a very different reason, and have very
| different code. 3. \*Error Handling\*: The
| error handling for the `TimeElapsed` event is not robust
| enough. It should handle cases where the time elapsed is
| less than zero or exceeds a certain threshold. //
| Negative time elapsed? Are we time-traveling? Where is my
| time DeLorean? 4. \*Logging\*: The logging
| functionality could be improved by adding more detailed
| logs and making it configurable. 5.
| \*Testing\*: The test functions in `TestBS` and `TestBS2`
| are repetitive and could be refactored into a single test
| function that handles different scenarios. // This is
| outside main.py 6. \*Code Readability\*: Some
| of the code is quite verbose, which can make it harder to
| read and maintain. Refactoring can help improve
| readability by simplifying complex logic or breaking down
| large functions into smaller ones. 7.
| \*Configuration\*: The simulation parameters are
| hardcoded in `main.py`. It would be better to allow these
| parameters to be configurable through command-line
| arguments or a configuration file. 8. \*Error
| Handling for Market Orders\*: The error handling for
| market orders is not robust enough, especially when
| dealing with negative amounts or invalid asset types. //
| LOL, you have never shorted the market, haven't you?
| 9. \*Logging and Debugging\*: The logging and debugging
| information could be more detailed and easier to
| understand. 10. \*Code Organization\*: The
| code can be organized into modules or packages to improve
| maintainability and scalability. These are
| just a few potential areas for refactoring. Depending on
| the specific requirements and constraints of your
| project, you may want to focus on different aspects of
| the code. > Tokens: 12k sent, 405 received.
| #### /ask how would you organize the code in modules?
| #### how would you organize the code in modules?
| Organizing code into modules can improve maintainability,
| scalability, and readability. Here are some steps you
| could take to refactor `main.py` into modules:
| 1. \*Create a Module for Simulation Initialization\*:
| Create a new module named `simulation.py`. This module
| will contain the `init_simulation()` function that
| initializes the simulation. 2. \*Create a
| Module for Market Classes\*: Create a new module named
| `markets.py`. This module will contain the `Market_v1`,
| `Market_chaos_v1`, and any other market-related classes.
| 3. \*Create a Module for Logger\*: Create a new module
| named `logger.py`. This module will contain the `Logger`
| class. 4. \*Refactor Main Function\*: Move the
| `run()` function into the `simulation.py` module, as it
| is responsible for initializing and running the
| simulation. 5. \*Organize Other Functions\*:
| Move any other functions that are not directly related to
| simulation initialization or market classes into their
| respective modules. 6. \*Use Import
| Statements\*: Use import statements in your main file
| (`main.py`) to import the necessary functions and classes
| from these modules. Here's a basic example of
| how you might structure the code: ###
| `simulation.py` ```python from markets import
| Market_v1, Market_chaos_v1 from logger import
| Logger def init_simulation(): #
| details omitted ``` ### `markets.py`
| ```python from dataclasses import dataclass
| @dataclass class Stock: pass
| @dataclass(unsafe_hash=True) class Option:
| strike: int type: str # 'c' or 'p'
| expiration: int @dataclass class
| MarketOrder: amount: int asset:
| object # Union[Stock, Option] # Why did you replace my
| type? @dataclass class Quote:
| price: float @dataclass class
| TimeElapsed: current_time: float
| class Simulator: # details omitted ```
| ### `logger.py` ```python from dataclasses
| import dataclass @dataclass class Stock:
| pass @dataclass(unsafe_hash=True) class
| Option: strike: int type: str # 'c'
| or 'p' expiration: int @dataclass
| class MarketOrder: amount: int asset:
| object # Union[Stock, Option] # Why did you replace my
| type? @dataclass class Quote:
| price: float @dataclass class
| TimeElapsed: current_time: float
| class Logger: # details omitted ```
| ### `main.py` ```python from simulation
| import init_simulation def run(start_time=0,
| end_time=6, increment=0.1): # details omitted
| def main(): # details omitted if
| __name__ == '__main__': #import cProfile
| #cProfile.run('main()') main() ```
| By organizing the code into modules, you can make it
| easier to manage and maintain. Each module will have a
| clear responsibility, making it easier to understand and
| work with the codebase. > Tokens: 13k sent,
| 850 received. #### /ask why are some
| dataclasses in the logger.py module in your proposal?
| #### why are some dataclasses in the logger.py module in
| your proposal? In the proposed refactoring of
| `main.py`, the `Logger` class is defined in its own
| module named `logger.py`. This is because the `Logger`
| class is not directly related to the simulation or market
| classes, and it has no dependencies on any other parts of
| the codebase. By placing the `Logger` class in
| a separate module, you can keep the main logic of the
| simulation and market classes focused on their respective
| responsibilities. This separation also makes it easier to
| manage and maintain the codebase, as each module is
| responsible for a specific aspect of the application.
| Additionally, by keeping the `Logger` class in its own
| module, you can reuse it across different parts of the
| application if needed, without having to duplicate the
| code. > Tokens: 14k sent, 150 received.
| #### /ask Can you put only the logging classes in
| logger.py? #### Can you put only the logging
| classes in logger.py? Certainly! If you want
| to keep only the logging-related classes in `logger.py`,
| you can modify the structure as follows: ###
| `logger.py` ```python from dataclasses import
| dataclass @dataclass class Stock:
| pass @dataclass(unsafe_hash=True) class
| Option: strike: int type: str # 'c'
| or 'p' expiration: int @dataclass
| class MarketOrder: amount: int asset:
| object # Union[Stock, Option] @dataclass
| class Quote: price: float @dataclass
| class TimeElapsed: current_time: float
| class Logger: # details omitted ```
| ### `simulation.py` ```python from markets
| import Market_v1, Market_chaos_v1 from logger
| import Logger def init_simulation():
| # details omitted ``` ### `main.py`
| ```python from simulation import init_simulation
| def run(start_time=0, end_time=6, increment=0.1):
| # details omitted def main(): #
| details omitted if __name__ == '__main__':
| #import cProfile #cProfile.run('main()')
| main() ``` In this refactoring, the
| `Logger` class is moved to its own module, and only the
| necessary classes from `markets.py` are imported into
| `simulation.py`. This keeps the `logger.py` module
| focused solely on logging-related functionality.
| > Tokens: 14k sent, 429 received.
| simonw wrote:
| If you are using Ollama that suggests you are using local
| models - which ones?
|
| My experience is that the hosted frontier models (o3, Gemini
| 2.5, Claude 4) would handle those problems with ease.
|
| Local models that fit on a laptop are a lot less capable,
| sadly.
| javcasas wrote:
| I have tried with qwen2.5-coder:3b, deepseek-coder:6.7b,
| deepseek-r1:8b, and llama3:latest.
|
| All of them local, yes.
| simonw wrote:
| That explains your results. 3B and 8B models are _tiny_ -
| it 's remarkable when they produce code that's even
| vaguely usable, but it's a stretch to expect them to
| usefully perform an operation as complex as "extract the
| dataclasses representing events".
|
| You might start to get useful results if you bump up to
| the 20B range - Mistral 3/3.1/3.2 Small or one of the
| ~20B range Gemma 3 models. Even those are way off the
| capabilities of the hosted frontier models though.
| bubblyworld wrote:
| For what it's worth, commercial models are in a completely
| different league to locally runnable models. If you are
| really interested in seeing state of the art right now at
| least give it a whack with opus/gemini/o3 or something of
| that calibre.
|
| You might still be disappointed but at least you won't have
| shot your leg off out of the gates!
| javcasas wrote:
| I'm trying to use local models for privacy reasons. Also,
| at some point, one of the employers out there will start
| suing people because those people shared code with a
| commercial model, and the commercial model decided to train
| on that code and output learned code to someone else. I'm
| not interested in anything of such a situation.
| osigurdson wrote:
| While I didn't agree with the "junior developer" analogy in the
| past, I am finding that it is beginning to be a bit more like
| that. The new Codex tool from OpenAI feels a lot more like this.
| It seems to work best if you already have a few examples of
| something that you want to do and now want to add another. My
| tactic is to spell it out very clearly in the prompt and really
| focus on having it consistently implement another similar thing
| with a narrow scope. Because it takes quite a while, I will
| usually just fix any issues myself as opposed to asking it to fix
| them. I'm still experimenting but I think a well crafted spec /
| AGENTS.md file begins to become quite important. For me, this +
| regular ChatGPT interactions are much more valuable than
| synchronous / Windsurf / Cursor style usage. I'd prefer to review
| a more meaningful PR than a million little diffs synchronously.
| jugg1es wrote:
| I have found it fascinating how AI has forced me to reflect on
| what I actually do at work and whether it has value or not.
| api wrote:
| Those kinds of thought processes are the kinds that produce
| value.
|
| Deciding what to build and how to build it is often harder than
| building.
|
| What LLMs of today do is basically super-autocomplete. It's a
| continuation of the history of programming automation:
| compilers, more advanced compilers, IDEs, code generators,
| LINTers, autocomplete, codeinsight, etc.
| qwertox wrote:
| > Meanwhile, I feel like if I tried to offload my work to an LLM,
| I would both lose context and be violating the do-one-thing-and-
| do-it-well principle I half-heartedly try to live by.
|
| He should use it as a Stack Overflow on steroids. I assume he
| uses Stack Overflow without remorse.
|
| I used to have 1y streaks on being on SO, now I'm there around
| once or twice per week.
| orochimaaru wrote:
| My thesis is actually simpler. For the longest time until the
| Industrial Revolution humans have done uninteresting work for the
| large part. There was a routine and little else. Intellectuals
| worked through a very terse knowledge base and it was handed down
| master to apprentice. Post renaissance and industrial age the
| amount of known knowledge has exploded, the specializations have
| exploded. Most of what white collar work is today is managing and
| searching through this explosion of knowledge and rules. AI (well
| the LLM part) is mostly targeted towards that - making that
| automated. That's all it is. Here is the problem though, it's for
| the clueless. Those who are truly clueless fall victim to the
| hallucinations. Those who have expertise in their field will be
| able to be more efficient.
|
| AI isn't replacing innovation or original thought. It is just
| working off an existing body of knowledge.
| RugnirViking wrote:
| I disagree that ancient work was uninteresting. If you've ever
| looked at truly old architecture, walls, carvings etc you can
| see that people really took pride in their work, adding things
| that absolutely weren't just pure utility. In my mind that's
| the sign of someone that considers their work interesting.
|
| But in general, in the past there was much less specialization.
| That means each individual was responsible for a lot more
| stuff, and likely had a lot more varied work day. The
| apprentice blacksmith didn't just hammer out nail after nail
| all day with no breaks. They made all sorts of tools, cutlery,
| horseshoes. But they also carried water, operated bellows, went
| to fetch coke etc, sometimes even spending days without
| actually hammering metal at all - freeing up mental energy and
| separation to be able to enjoy it when they actually got to do
| it.
|
| Similarly, farm laborers had massively varied lives. Their
| daily tasks of a given week or month would look totally
| different depending on the season, with winter essentially
| being time off to go fix or make other stuff because you can't
| do much more than wait to make plants grow faster
|
| People might make the criticism and say "oh but that was only
| for rich people/government" etc, but look at for example old
| street lights, bollards etc. Old works tend to be
|
| Specialization allows us to curse ourselves with efficiency,
| and a curse it is indeed. Now if you're good at hammering
| nails, nails are all you'll get, morning to night, and rewarded
| the shittier and cheaper and faster you make your nails,
| sucking all incentive to do any more than the minimum
| jacobolus wrote:
| Hunter-gatherers have incredible knowledge and awareness about
| their local environment - local flora and fauna, survival
| skills, making and fixing shelters by hand, carpentry, pottery,
| hunting, cooking, childcare, traditional medicine, stories
| transmitted orally, singing or music played on relatively
| simple instruments, hand-to-hand combat, and so on - but live
| in relatively small groups and are necessarily generalists. The
| rise of agriculture and later writing made most people into
| peasant farmers, typically disempowered if not enslaved (still
| with a wide range of skills and deep knowledge), and led to
| increasing specialization (scribes, artisans, merchants,
| professional soldiers, etc.).
|
| Calling this various work "uninteresting" mostly reflects on
| your preferences rather than the folks who were doing the work.
| A lot of the work was repetitive, but the same is true of most
| jobs today. That didn't stop many people from thinking about
| something else while they worked.
| rwyinuse wrote:
| I would say that mastering things like building, farming,
| gardening, hunting, blacksmithing and cooking does require
| quite a bit of learning. Before industrial revolution most
| people engaged in many or all of those activities, and I
| believe they were more intellectually stimulated than your
| average office worker today.
| exe34 wrote:
| > Those who have expertise in their field will be able to be
| more efficient.
|
| My problem with it as a scientist is that I can't trust a word
| it writes until I've checked everything 10 times over. Checking
| over everything was always the hardest part of my job. Subtle
| inconsistencies can lead to embarrassing retractions or worse.
| So the easy part is now automatic, and the hard part is 10x
| harder, because it will introduce mistakes in ways I wouldn't
| normally do, and therefore it's like I've got somebody working
| against me the whole time.
| CommenterPerson wrote:
| Here we go again.
|
| But. "Interesting" is subjective, and there's no good definition
| for "intelligence", AI has so much associated hype. So we could
| debate endlessly on HN.
|
| Supposing "interesting" means something like coming up with a new
| Fast Fourier Transform algorithm. I seriously doubt an LLM could
| do something there. OTOH AI did do new stuff with protein
| folding.
|
| So, we can keep debating I guess.
| rorylaitila wrote:
| The one thing LLM cannot do currently is read the room. Even if
| it contains all existing information and can create any requested
| admixture from its training, that admixture space is infinite.
| Therefore the curators role is in creating with it the most
| interesting output. The more nuanced and sophisticated the
| interesting work, the more role there is for this curation.
|
| I kind of use it that way. The LLM is walking a few feet in front
| of me, quickly ideating possible paths, allowing me to experiment
| more quickly. Ultimately I am the decider of what matters.
|
| This reminds me a bit of photography. A photographer will take a
| lot of pictures. They try a lot of paths. Most of the paths don't
| actually work out. What you see of their body of work is the
| paths that worked, that they selected.
| overgard wrote:
| LLM's can't really reason, in my opinion (and in a lot of
| researchers), so, being a little harsh here but given that I'm
| pretty sure these things are trained on vast swaths of open
| source software I generally feel like what things like Cursor are
| doing can be best described as "fancy automated plagiarism". If
| the stuff you're doing can be plagiarized from another source and
| adapted to your own context, then LLM's are pretty useful (and
| that does describe a LOT of work), although it feels like a
| little bit of a grey area to me ethically. I mean, the good thing
| about using a library or a plain old google search or whatnot is
| you can give credit, or at least know that the author is happy
| with you not giving credit. Whereas with whatever Claude or
| ChatGPT is spitting out, I mean, I'm sure you're not going to get
| in trouble for it but part of me feels like it's in a really
| weird area ethically. (especially if it's being used to replace
| jobs)
|
| Anyway, in terms of "interesting" work, if you can't copy it from
| somewhere else than I don't think LLMs are that helpful,
| personally. I mean they can still give you small building blocks
| but you can't really prompt it to make the thing.
___________________________________________________________________
(page generated 2025-07-07 23:01 UTC)