Remix.run Logo
▲ CharlieDigital a day ago

It doesn't have to be this way.

AI is great at following patterns. AI is great at writing tests. AI is great at doing work that humans would consider drudgery and then applying "enough" judgement to it.

The problem is that most software teams and most engineers are very, very bad at the thing that AI needs to succeed: technical writing. Documenting the patterns, the rules, the heuristics, the SOP, the judgement; developers could barely be bothered to write comments before (which in the AI age are free, infrastructure-less memory that is always "line-of-sight" for the agent and can be used to enrich with keywords).

It's not that AI is the problem, it's that we humans are good at resolving these constraints in the real world at a human pace. AI makes that pace impossible for a human to keep up as a trailing activity. Rather teams need to invest more in technical writing and producing the corpus that AI relies on to learn the operational constraints and rules.

▲asdfman123 a day ago | parent | next [-]

I'm actually quite good at building robust systems, cleaning up messes, documenting things well.

As a result I get:

1) The enmity of my lead dev who prefers to do things more fast and loose.

2) Not promoted, due to the first reason and due to the fact that I don't have "impactful" metrics.

I'm not saying I'm perfect, there are definitely things I could have done better. But the fact still remains that the industry grossly undervalues maintenance and optimization that doesn't lead to easily measurable numbers that impact the bottom line.

That in turn is because it's hard to tell if SWEs are actually paying down critical debt or just wasting time. But that's the core problem, not that we're not good at it.

The good news is I can get AI agents to do this kind of work so I can now chase after metrics.

▲sushisource 20 hours ago | parent | next [-]

I think this thinking misses the forest for the trees a lot of the time. Assuming you're as good as you say you are at this, you need to ask how much building robust maintainable systems _actually helps the business_. The number of products where being super duper robust actually matters is probably less than you think. It can be painful as an engineer to accept, but it's often true.

I actually happen to work on a product where reliability _is_ our #1 most critical thing, and even then in certain features and certain situations it is perfectly reasonable to prefer time-to-market over quality as long as we are clear about that to our users.

So, I'd encourage you to think from a product perspective.

▲ctkhn 18 hours ago | parent [-]

We have a similar issue but when you look at it long term it still doesn't make sense from a product perspective. We have incredibly brittle and unreproducible env setups from local (just got working this year) to dev, qa, pre-prod etc. and some tickets to automate away a lot of that work would be paid off within a quarter. Instead everyone up to and including staff engineers does nothing about it. Even our documentation of infra setups in lower environments (that prod support uses to set up higher envs) is very sloppy. But no one is evaluated on it at all. I still do it thoroughly myself just so I don't have to re-learn things when I see them again a year later but otherwise there would be no point.

▲jgord a day ago | parent | prev | next [-]

I think this is a real alignment issue - nobody has excess time/money to make the software robust/secure.

This is possibly due to the high level of economic inequality, meaning less resources in the middle of the economy.

In a decade I think we will have few people who can competently write or even read computer code without AI assistance.. and I think we might say the same about math and science and medicine.

AI assisted learning could lead to a renaissance of human capability .. but thats not where we are headed, we are outsourcing all the hard thinking skills. In future, only a few crazy retro nerds will learn assembler or multivariable calculus, just as only a few crazy nerds now make mechanical watches as art objects.

▲jgord a day ago | parent | next [-]

In my own social circles I hear of capable young people who want to forego university and just take up a trade, because it avoids debt.

Excessive inequality means we wont be training young scientists, and young couples will defer having children until its biologically too late.

High inequality + LLM AIs + climate change is not a recipe for human flourishing.

▲mschuster91 a day ago | parent [-]

University means knowledge work, and knowledge work is already getting fucked over by AI. The clankers can now design rudimentary PCBs. The only university degrees that will not be compromised by AI are the ones that deal with humans in the meatspace - think medicine, psychology or education, although I think we might be getting a revisit of MOOCs augmented by AI to drastically reduce the need for teachers.

Being good at one of the trades however? That's a pretty safe bet. It will be quite the time until physical robot "bodies" are capable of the dexterity, size and endurance of a human. And by the time robots get that capability, we're either living in a Star Trek utopia or in Matrix style neo-feudalism.

▲asdfman123 a day ago | parent | prev | next [-]

> This is possibly due to the high level of economic inequality,

Friend, I work for Google. The high level of inequality works completely in our favor, yet we are incentived to churn out slop that hits metrics.

▲ponector 21 hours ago | parent | prev | next [-]

>> nobody has excess time/money to make the software robust/secure

That is not true. Microsoft is extremely profitable. Apple as well. Amazon. Banks are literally printing money. All of them have resources to produce robust secure software.

They just decided not to go that way.

▲pixl97 21 hours ago | parent | prev [-]

>nobody has excess time/money to make the software robust/secure.

Regulations are written in blood. No industry regulates itself at first. It's always no brakes, no safeties until a horrific event occurs, then the crackdown comes.

▲palata a day ago | parent | prev | next [-]

I feel similarly: I am slow but solid. The industry values those who move fast, break things, and make a mess.

Which makes sense: those in a position to promote others generally don't understand the technical part. What they see is how fast they get a new toy to play with. And if it breaks too soon, they will still be able to blame the developers.

▲cess11 a day ago | parent | prev | next [-]

While you do that, look for opportunities in niches where "fast and loose" is unacceptable, because while they might not market themselves as loudly as most software development organisations they do actually exist.

Typically these places are associated with compliance, audits and regulation with teeth. It might be adjacent to lawyers, in public institutions or weird consultancies. At least that's where I've found such work. Insurance and banking might be decent bets, and they sometimes also come with oddball tech stacks, perhaps mainframes, perhaps Smalltalk.

▲RetroTechie an hour ago | parent [-]

And a whole field like that is about to explode: robotics. Add self-driving vehicles too.

▲mock-possum 11 hours ago | parent | prev [-]

sounds like you’re just at the wrong company / on the wrong team - and unfortunately the job market is scary enough that it’s not so easy to just jump ship these days. Very frustrating.

▲cmiles74 a day ago | parent | prev | next [-]

The urge to one-shot everything isn't helping. Getting people to push back on assumptions the model is making, and to have an actual conversation with it about the solution, would lead to more maintainable output.

Maybe part of it is laziness but for sure part of is low morale and hopelessness.

▲Fr0styMatt88 a day ago | parent [-]

Part of it is the hype cycle too. Everywhere you look online, all the easy examples are people one-shotting this and that. Strangely it seems like the 'standard' way for people on YT to 'test' a model is to just one-shot some random game idea. It's meaningless, but it creates this unconscious expectation (even amongst experienced devs who might not be as experienced in AI use) that the models _should_ be able to derive exactly what's needed from a one-shot.

That's fundamentally impossible though -- if the information isn't there, the model is just going to move toward the average and fill in the blanks.

On another note, I'm also not sure where I stand yet on the thing I see where software devs end up falling down the rabbit hole of building little mini software factories, with agents reviewing agents, coordinating agents and having agents cosplay human roles -- essentially 'orchestration porn'. I'm yet to dive into that rabbit hole (I likely will at some point, so I'm not judging), but from the outside it looks like you end up worsening your understanding of the system, while spending tokens unnecessarily and creating a closed-loop mini model collapse.

I've actually run into the situation at work where I've asked people whether the libraries they've made can do a particular thing and sometimes the answer has been "I don't know" (I'm talking just _features_, not even low-level architecture). At that point, something has gone wrong.

I'm starting to get really interested in "Okay, if human code review is fundamentally impossible given the volume of code, what can we do?". We have a tool that can essentially build tools for almost free, so I'm trying to approach it from that angle. Let's see what sticks.

▲ModernMech a day ago | parent | next [-]

> it creates this unconscious expectation (even amongst experienced devs who might not be as experienced in AI use) that the models _should_ be able to derive exactly what's needed from a one-shot.

It also creates an expectation that anything done with AI as part of the process was done in one shot, and therefore the person had no meaningful impact on the output.

▲Fr0styMatt88 a day ago | parent [-]

Oh this so much.

I saw a Reddit post of someone asking essentially “I’ve spent the last 7-8 months working with Claude on a game, am I really making something?” and I just wanted to reply “of course you f****ng are, don’t let people tell you otherwise!”

▲ModernMech a day ago | parent [-]

For this reason, I keep a "how it started / how it's going" log for everything I work with, to show how it looked after the first prompt, versus how it ended up after extensive work. Just to make clear how my input actually mattered to the output.

▲theresanagent 9 minutes ago | parent | prev | next [-]

[flagged]

▲AlienRobot a day ago | parent | prev [-]

I think the correct way to solve this problem is completely at odds with AI.

Write less code. Reuse things that have already been written and thus were already reviewed and tested by someone else. Do not reinvent the wheel. KISS.

With AI everyone is implemented a dozen libraries from scratch in their project instead of using something someone else made. Why use a library for 2D geometry when ChatGPT can write one in 10 minutes?

▲cmiles74 a day ago | parent [-]

I have to think part of this is model training, encouraging the model to code-up something new instead of looking for library code that can fit in the project. One of the things I ask Claude repeatedly is something like "can Spring do this already, or is someone working on this already?"

More tokens, more money.

▲eikenberry a day ago | parent | prev | next [-]

> The problem is that most software teams and most engineers are very, very bad at the thing that AI needs to succeed: technical writing.

Software engineers were at least pretty good at technical writing using the artificial languages we created to enable clear, unambiguous technical writing... programming languages. Seems like software engineers might do better using AI if they remembered this and started using pseudo-code as their language for spec writing (as many have recommended).

▲bonesss a day ago | parent [-]

Some large percentage of the dialogue around LLM prompting boils down to arguments we should be speaking to them in Haskell.

▲black_knight a day ago | parent [-]

They understand Haskell (and even Agda) remarkably well. One must just get their context out the degenerate state where they use strings, ints and bools for everything, and then they will happily write truly robust pieces of code!

They can even write good property based tests, with impressive Arbitrary instances for everything!

▲jltsiren a day ago | parent | prev | next [-]

That just follows from the fact that people can learn. Human organizations always have to balance between tacit knowledge and explicit documentation. Document too little, and onboarding new people will be more difficult, and you will lose information when people quit. Document too much, and you are just wasting time without doing anything productive, because people would have figured out that extra information in less time than it took to write it down.

The fundamental problem is that current AI tools don't learn. They make the same mistakes over and over again, unless you give them explicit instructions to avoid those mistakes. Maybe we need to accept that all work is now done by new hires, who have read all the documentation but have no experience in anything. Or maybe AI tools will get better, and all that tedious documentation effort was just a waste of time.

▲pixl97 a day ago | parent | next [-]

>current AI tools don't learn

and

>and all that tedious documentation effort was just a waste of time.

Seeing where the AI is failing and then putting out good public documentation is a good way to ensure the next released model learns.

▲jltsiren a day ago | parent [-]

Public documentation can help to mitigate the issue, but only with information that can be released to the general public, and only if it can be easily put into words. But as long as there is a separation between training and inference, the divergence between what the model knows and what it should know only grows wider over time.

I've been one of the organizers of a relatively large RPG convention for ~25 years. If I had to write down all I know about that convention, it would easily take a year or two. Because most of that knowledge is not in a form that can be easily expressed in words. And in my day job as a scientist, a similar task would easily take 5–10 years.

▲CharlieDigital a day ago | parent | prev [-]

    > The fundamental problem is that current AI tools don't learn
They don't learn, but they are very, very good at searching. That is why writing things down is important, but so is getting that into some sort of agent accessible index.
▲Geof25 a day ago | parent | prev | next [-]

I absolutely agree, as a child of automotive industry I am looking on software development through the lenses of kaizen loop. If you can loop the development cycle so it can correct itself through tests, then errors, either human or AI made are never going to be a problem, they will get self corrected by the testing.

Where do you get the correct test results? First from the specifications, then gradually from the edge cases found by testers and eventually users. It is not one shot process it is a big loop which will get repeated over and over again until users will run out of things to break.

The software is breaking because nobody is bothered to write down what is software actually supposed to do, and from there to create a set of tests which will anchor the behavior of software.

▲hibikir a day ago | parent | next [-]

Nobody bothers to write down what it's supposed to do because nobody thought about it enough for a full spec to be conceivable, let alone written. In a lot of modern development, you have a committee of non-technical product people who might, at best, own a single flow, but they sure don't own, and don't care, about the interactions across flows. And then you have development teams that live and die by KPI, and thus draw the edge of their responsibilities in the narrowest form possible. I was told by a subscription team in a certain very large company that they just own the subscription platform, not anything about the data in it, or the relationships mapped in the data. Bundling? Data. Billing? data. They are just 40+ people whose responsibility is to keep a database up, and therefore no outcomes other than inability to retrieve the data was ever their problem.

So who owns outcomes? Usability across the board? General customer experience? Nobody. The actual software that people pay for, is orphaned, and anyone trying to track down problems is just asking to be blamed for them. Thus, most of what happens is undefined behavior, like if we were writing an old C standard. Having someone that has the responsibility to make the product as a whole do something, and thus maybe be able to write the spec eventually, would already be an improvement.

▲codebje a day ago | parent | prev [-]

Feature churn moves faster than this sort of feedback loop does.

▲ajb a day ago | parent | prev | next [-]

The problem is not the input (documentation) it's the evaluation of the output. Managing an AI is like managing a team of specialists, whose subjects you are not a master of. Most programmers did not have the problem of managing experts - we were the experts. There are those that do, but several of the levers you have over a team of humans (incentives, responsibility, even hiring and firing) are not available to control an AI, and the new levers ( fine tuning, training, reinforcement learning) are not in the hands of those relying on it. This is not solved by any amount of documentation.

▲CharlieDigital a day ago | parent [-]

You hand the same documents over to AI agents that evaluate the output.

The same rules that you, an expert would apply, should be documented and used by an agent to apply those heuristics.

There are obviously some areas where there's spot judgement, deviations, and exceptions. But by and large, you have some heuristic that you use when evaluating output. Document it and give it to an agent.

▲ajb a day ago | parent [-]

This suffices for merely random error (as long as the error is demonstrable) but it's not a general solution to the problem.

▲kragen 21 hours ago | parent | prev | next [-]

I've been forming this hypothesis, too: that the thing that AI needs to succeed is technical writing, "documenting the patterns, the rules, the heuristics, the SOP, the judgement." Certainly, when I do it, it seems to help, and when AI goes off-track, it seems to often be traceable to me not doing enough technical writing.

But I wonder: am I possibly engaging in wishful thinking? I believe myself to be good at technical writing, so it would certainly be very flattering for my ego if technical writing were suddenly the thing that AI needs to succeed. So I'm a little skeptical of this perception of mine!

How would you convince someone skeptical that technical writing is the thing AI needs to succeed?

(QA, incidentally, is another thing I think I'm particularly good at, and I have the impression that it's also crucial to the success of current AI, and it's not the same thing as technical writing. AI can identify when code crashes, doesn't pass automated tests, or doesn't look like the wireframe, but it's not yet very good at identifying when it's difficult to use or confusing.)

▲dabinat 21 hours ago | parent | prev | next [-]

> developers could barely be bothered to write comments before (which in the AI age are free

I consider the comments AI writes to be far worse than the code. I am rewriting them a lot more often than I rewrite the actual code. They are overly wordy and include a lot of unnecessary asides that make it sound like a LinkedIn post. Or it will reference specific irrelevant things in the prompt that won’t matter when someone looks at it 6 months from now.

▲CharlieDigital 2 hours ago | parent [-]

That purely depends on how you write comments.

Things that are really useful in comments:

    - URLS to llms.txt or other authoritative docs so agents see it, read it
    - Related entities that may require multiple hops to deduce; you can short circuit the agents read by directly pointing your comment to a related entity that may not show up directly in the call path (e.g. separated by a message queue)
    - Reasoning and "why" a decision was made so in a future pass, an agent understands why a condition or rule exists
You can write bad comments, but you can now just prompt/instruct your agents to write good comments and use it as long-term memory.
▲matwood a day ago | parent | prev | next [-]

You're asking ICs to become managers of a bunch of mid-level developers (agents). It's a skill that has to be developed like any other, and takes time.

▲palata a day ago | parent [-]

And in my experience in the software industry, most managers are bad (presumably because they didn't develop that skill either).

It was like that before AI, it won't get better now that we need even more people to pretend they know how to manage developers.

▲dotdi a day ago | parent | prev | next [-]

It does have to be this way, unfortunately, because AI bros will press to have as much software produced at the absolute minimal cost possible.

I've seen it first hand. 70 people fired, 20 people left. The 20 that are left take on all the work that was done before, plus some extra, because every company now has a new AI product, obviously. AI agents make us so productive. Every review is a 30 second LGTM on 500 new lines of code. Confluence filling up with AI slop.

A few weeks back I saw, first hand, a DevOps lead getting ready to ship a big update to performance-critical product where Opus 5.5 suggested they completely turn off JIT everywhere because they were running into a HotSpot C2 optimizer bug that would make the first request after a restart fail with a 500. Actual fix was a one-line adjustment somewhere in a library.

People are scared of being replaced, so they need to appear as productive as possible.

▲CharlieDigital a day ago | parent | next [-]

You can be productive and guide AI to operate in a more compliant way: by writing down basically everything you know, every heuristic you have, documenting the correct patterns, documenting the framework level approach, explicitly spelling out what's good code, writing down detailed specs for an agent to work on, writing the test plan, etc.

A lot of devs still think their job is to produce code; it's actually to produce all of the guidance and structural scaffolding for the agents ("the harness") to guide its behavior and output.

A concrete example: I wrote a small library[0] (MIT, OSS) that improves how agents write unit and integration tests. This isn't product code, but this makes the agent better at writing the tests it uses to verify its work. (Tests become denser, more semantic, less context, type-checked setup, etc.). You can't expect an agent to do this by itself; the human needs to produce the scaffolding.

[0] https://github.com/zeeq-ai/zeeq-biome

▲Terr_ 21 hours ago | parent | next [-]

> You can be productive and guide AI to operate in a more compliant way: by writing down basically everything you know, every heuristic you have [...]

If its ends up being really that straightforward, it sounds less like engineering a product and uncomfortably close to building your own to corporate-owned replacement so that you can be fired.

▲boorang a day ago | parent | prev | next [-]

agree- this is how i name variables, this is how we handle third party APIs, this is how we handle caching and here are some heuristics for when we want to cache and when we want to avoid it, etc. etc. all coded up in a nice documentation tree with links in the agents.md that say "when integrating with third party APIs, read docs/integrating-with-third-party-apis.md".

i have written alot of this type of documentation as an architect for human teams, and i find it works for agents as well.

▲skydhash a day ago | parent | prev | next [-]

> A lot of devs still think their job is to produce code; it's actually to produce all of the guidance and structural scaffolding for the agents ("the harness") to guide its behavior and output.

This basic reasoning is wrong and leads to “orchestration porn”. Thinking that you can laid down rules to automate software production like it’s a factory pumping out products.

What you forget is that software are grown iteratively, not guided down some assembly line. Every patch is a revision of what the software should do, not the next step of a workflow.

So stuff like patterns, architecture, tests,… are helpers for communicating the purpose of the software. They’re not really relevant to the software itself as the computer would be happy with just a single file.

You have a software that’s needed to fulfill some needs, you have a team of people where each brings expertise to build it. Workflows are built so that everyone how to contribute, what they can depends on, and what others need. When there’s a failure, we add the missing information. When there’s need to do some changes, we inform everyone impacted.

Everything is information and communication related. Information about the system and communication between everyone that interacts with the latter.

So devs do not think their job is to produce code. It is to take requirements written in ambiguous natural language, sometimes incomplete and contradictory, and to design a solution that is formally written while taking care that all statements are coherent.

Making things coherent (aka correct) is what takes the majority of our time. The other is gathering requirements. The actual typing of code is pretty much instinctive, just like you don’t check the orthography of words like “concrete” or “guide”, and rely on the spellchecker for more difficult one.

The “orchestration porn” part is that there’s no mention anywhere on how you think correctness and be improved or even maintained as part of your tool.

▲chickensong a day ago | parent | next [-]

Your argument seems to be about refuting a generalized one-size-fits-all approach, which can have its place, but there's nothing preventing per-project "orchestration porn" that works very well. Bind the harness to the project and your agent will help you with the non-code tasks as well.

> there’s no mention anywhere on how you think correctness and be improved or even maintained as part of your tool.

The first paragraph is literally a list of examples, followed up by a specific library that helped the OP. The paragraph you quoted explains where the maintenance lies.

▲Fr0styMatt88 a day ago | parent | prev [-]

I view the thing I’m ultimately providing to an AI agent is ‘executive function’, in the sense of how it’s used when talking about ADHD; one of the core executive functions is retrieving the right skills and/or information to use, at the point of performance.

AI agents don’t have this in a sense; or they do, but it’s average and stochastic. We have to be in the loop to provide judgement and manage the agent’s context; the content of that context steers the agent in the direction that our judgement tells us the development should go, to meet the various requirements. Some of those requirements are around the software’s function, some around maintainability, some around understandability, etc.

I think scaffolding is good at decreasing the amount of repeated mistakes and ensuring the agent can request and receive information efficiently. I think software factories are too self-referential; I’m not set on that opinion though and like I’ve said in another comment, I will fall down this rabbit hole at some point just to see what it’s like.

So many times I’ve wondered “you know how to do this, so why didn’t you just do it the first time?” — the old “Oh you’re absolutely right! That’s a much better way to do it!”.

It’s not that the model doesn’t have the knowledge, it’s that it doesn’t access it at the time it is needed. Part of my job now is to collaborate with the models and the tools.

▲skydhash 20 hours ago | parent [-]

From my experience there's always two parts in working with code. The deterministic part where you can derive information from the code itself and do some action, mostly used by static analysis tools (type checker, linting,...) and there's another much harder to define part like "this part of the code is unreadable and/or does not mean what the requirement says".

The first is solved by deterministic tool as code is already formal, so the grammar is very strict and fully defined. But the second part is entirely human dependent of what the end result should look like, even when the same semantics is being kept. That's why two people asked to implement the same task will code it differently even if from the point view of the machine, they're equivalent.

Maintainability and readability is not about software correctness. It's about how the human mind can absorb what the software should do, aka the specs embedded in the code, which is just formal notation. If it's easy, then the software correctness is easy to check and validate. And when the requirements changes, it's easy to apply the needed modifications.

So asking agents to improve upon that is like asking an agent to write an email. It's an alienation of human-human communication.

▲xmcqdpt2 a day ago | parent | prev | next [-]

Do you have eval testing? Benchmarks? Deterministic model checkpoints? Deterministic harness versioning?

Building "orchestration" without being able to deterministically measure improvements is not engineering, it's cargo cult.

▲CharlieDigital an hour ago | parent [-]

I don't know about you, but I watch my agents work and spot check work.

I also have a set of tools[0] specifically built to address this by surfacing agent usage of context and harness usage of tools.

Do I version? In some cases, yes. The tool I built for our team has configurable code review agents that trigger both in PRs and "in-the-loop" for the agent (exposes the same remote reviewer as MCP). It has an option to build a dataset to backtest changes to the code review prompts[1] and prompt history is saved as are dataset versions.

[0] https://zeeq.ai/

[1] https://zeeq.ai/docs/managing-zeeq/agent-code-reviews#backte...

▲haukebri a day ago | parent | prev [-]

Agreed on writing the test plan down. The harder part for me was what comes out of it. The tests an agent writes in my repo pass and protect nothing: copy text asserted as a fixed string, a component mocked away and then asserted on, three tests checking the same thing in different words. Coverage goes up and real breakage walks straight through.

Deleting first is what changed it for me. I go through the suite, cut everything that doesn't map to a flow a user actually goes through, then keep a few that drive the deployed app end to end. Fewer tests, noisier when one fails, and I trust them now.

The test plan is still the bit I can't hand over, because deciding what a flow is supposed to do is where I get it wrong myself.

▲cmiles74 a day ago | parent | prev | next [-]

I suspect the majority of reviews had been a rubber stamped LGTM. Often the minority with substantive feedback were heeded and changes made; I'm not sure that is happening anymore.

▲asdfman123 a day ago | parent | prev | next [-]

> AI bros

You have to stop thinking this way. It's our job to do what our management wants us to do, which is often to produce as much software at the lowest cost possible.

There are legitimate criticisms about AI use and how AI has changed the profession, but you have to learn which battles are worth fighting.

▲GolfPopper a day ago | parent | next [-]

We were just following orders!

The refusal to take responsibility for the consequences of one's work is one part of a vast complex of machines that normalize the horrific. We have met the shoggoths and they are us.

▲lproven an hour ago | parent | next [-]

Beautifully put.

The IT world needs to internalise understanding of the Peter Principle and Hanlon's Razor.

Don't just do what you're told. You also need to know why you were told it, and when to creatively disobey.

Embrace the power of "no".

▲ an hour ago | parent | prev [-]
[deleted]
▲palata a day ago | parent | prev | next [-]

> It's our job to do what our management wants us to do, which is often to produce as much software at the lowest cost possible.

Have you ever been in a situation where you did what the management wanted you to do for years, regularly warning them that you could not write good code while doing what they wanted but being dismissed because they knew better? And have you ever been in a situation where you finally got your "I told you so" moment after years, when they actually realise it won't work?

I have. You know what happens then? It's not their fault. Best case, they explain why you couldn't have known better because it was hard. Worst case, they fire you because... well you built that mess, remember?

What's the winning strategy for a dev in that situation? IMO it's adversarial: do whatever works for you: work less and pretend it's hard, or chase a better salary, don't get attached, and prepare to jump ship whenever needed.

Is it sad? Yes, but they start it.

▲rsoto2 a day ago | parent | prev | next [-]

Doing what management wants you to do blindly is an easy path to ruining the company and losing your job. We used to joke that the true mark of a senior engineer is being able to tell management when their ideas are stupid, will not work, and "no."

▲dotdi a day ago | parent | prev | next [-]

Just like crypto bros a few years back, where we "do what our management wants us to do", built stupid-ass blockchain into every every which app that didn't need it, and when it doesn't sell get blamed for it.

Personally, I was asking "but what's the use case" in every meeting. "Why would somebody pay for this". "Who's the customer". Right now the vibes are quite similar to back then.

▲Toynbeeidea a day ago | parent | prev [-]

Management are AI bros. Bro.

▲killix a day ago | parent | prev | next [-]

[flagged]

▲rsoto2 a day ago | parent | prev [-]

Dude, you just didn't write down the rules and the patterns effectively. Just write down "don't completely turn off JIT" /s

Damn if only there was a way to write strict rules and patterns in the english language that could be converted into strict instructions for the computers and ways to verify those instructions...

▲rsoto2 a day ago | parent | prev | next [-]

This is hilarious. Just "document the patterns and the rules" guys, then AI can do the rest.

I agree that humans are the problem and their gullibility towards token prediction algorithms and CEOs blathering.

▲CharlieDigital an hour ago | parent [-]

Have you tried it? Have you really invested in: 1) documenting your expert heuristics exhaustively, 2) ensuring the agent has the right tooling to find the text, 3) tuning the agent instructions so it uses the tooling correctly?

▲Forgeties79 a day ago | parent | prev | next [-]

SOP and documentation is everything. You don’t want it going out of bounds and coming up with its own solutions, which are often just inefficient facsimiles of random stuff it finds that seems to makes sense. You also run the risk of not understanding the solution it puts in front of you. With an ironclad SOP and quality documentation, you know when it is straying from the best paths, because they are laid out for both of you.

Plus your documentation can often work very well alongside whatever skills you have created over time, because you basically have two sources it is drawing on telling it to do the same thing. I find it leads to less off book behavior.

I’ve always been perplexed by how people see AI as this creative tool or something to innovate with. That’s not how I see it at all. I see it as a device that can follow a template very well if you lay good tracks. They can archive and check hundreds of pieces of media way faster than I can. But I would never trust it to craft a story

▲cmiles74 a day ago | parent [-]

IMHO, most places are pretty terrible and documentation. I work with people today that seem to think someone else is going to do it for them.

▲Forgeties79 a day ago | parent [-]

Well after five years of miserably keeping our SOP tight and templatizing (is that a word?) our edits aggressively, we are finally seeing some dividends with resolve’s recent Claude integration. It was a painful process but the amount of time we are now saving is well worth it. Also takes a lot of the drudgery out of editing. Anyone who has been a DIT before knows what I mean lol it’s nice to sit down to a prepared timeline that is already roughed in with multicam clips and effects all applied.

▲oulipo a day ago | parent | prev | next [-]

"AI is great at following patterns", sure but if some attackers can "inject attack patterns" at a high rate in your training set (check "dataset poisoning") then it's going to be an issue...

▲mitxela 10 hours ago | parent [-]

"high rate" can be one file out of millions.

4/5

▲logarhythm a day ago | parent | prev [-]

I completely agree, and I’m building a tool to solve exactly that challenge.

Pathfinder lets you understand your product’s building blocks. So you and your team pilot your agents at the product level, not the code level.

It’s augmented product engineering: https://pathfinder.com.ai