When I'm building, and get approached by large customers who have specific needs for them, those needs go at the end of our backlog. There's a hard and fast rule that unless it's an issue with authentication or accepting money, nobody gets to jump the line. We re-evaluate our backlogs periodically, and treat large-customer requests similarly to small-customer requests; who is this going to serve, what additional revenue could this generate, will this increase retention. If there are other projects that, combined, will move the needle more than doing one project for one enterprise client, guess what, that enterprise client doesn't get to jump the line.
"If a local district starts losing funding, then it would have to close / shrink schools, and people from outside the educational system would be allowed to establish independent (secular) charter schools within the district."
There is zero incentive for "people outside the educational system" to do this. Kids will absolutely suffer because of this plan.
The answer to this, like always, is that teachers need to be paid more.
If "we will opt everyone in because otherwise we won't get enough data because we know users won't opt in" is your business model, maybe it's time for a rethink.
Except you kind of do -- understanding data structures, understanding software engineering concepts, all of the things that you learn as a good engineer, those are ways that you help guide the LLM in its work.
> Another way to look at this is that AI coding agents take the fun out of a software engineer's job.
Completely backwards - the fun in the job should be to solve problems and come up with solutions. The fun in the job is not knowing where to place a semicolon.
Title clickbait for sure, but the process has radically changed in the past 6 months due to this new generation of models.
"Perfect code from the agent everytime" isn't really what the expectation is. Bugs are always going to be shipped into production, no matter who or what is writing the code. Where SDLC is really getting compressed is in the iteration phase.
For example:
- "This is a known good state; write tests to enforce this state" is something that takes minutes now instead of days. That is incredibly powerful for understanding and maintaining a system.
- Bugfixing is a matter now of an agent watching error logs, diagnosing traces, and immediately issuing PRs with suggested fixes, something that again would have taken hours at least and is now down to minutes (and can be a 24x7 operation, which for most businesses is a revelation).
- Engineers have the freedom to land enhancements that in the Before Times would have sat in the backlog for months and years on end because of the time commitment. That has knock-on effects of quality, features, and just overall improvements for users.
It is a very, very, very different world that we're operating in, and what used to be huge steps of the SDLC now take less time than checking your email in the mornings with your first cup of coffee.
I would argue that it's going to be the opposite. At re:Invent, one of the popular sessions was in creating a trio of SRE agents, one of which did nothing but read logs and report errors, one of which did analysis of the errors and triaged and proposed fixes, and one to do the work and submit PRs to your repo.
Then, as part of the session, you would artificially introduce a bug into the system, then run into the bug in your browser. You'd see the failure happen in browser, and looking at Cloudwatch logs you'd see the error get logged.
Two minutes later, the SRE agents had the bug fixed and ready to be merged.
"understand how these systems actually function" isn't incompatible with "I didn't write most of this code". Unless you are only ever a single engineer, your career is filled with "I need to debug code I didn't write". What we have seen over the past few months is a gigantic leap in output quality, such that re-prompting happens less and less. Additionally, "after you've written this, document the logic within this markdown file" is extremely useful for your own reference and for future LLM sessions.
AWS is making a huge, huge bet on this being the future of software engineering, and even though they have their weird AWS-ish lock-in for some of the LLM-adjacent practices, it is an extremely compelling vision, and as these nondeterministic tools get more deterministic supporting functions to help their work, the quality is going to approach and probably exceed human coding quality.
Many years ago, java compilers, though billed out as a multiple-platform write-once-run-anywhere solution, those compilers would output different bytecode that would behave in interesting and sometimes unpredictable fashion. You would be inside jdb, trying to debug why the compiler did what it did.
This is not exactly that, but it is one step up. Having agents output code that then gets compiled/interpreted/whatever, based upon contextual instruction, feels very, very familiar to engineers who have ever worked close to the metal.
"Old fashioned", in this aspect, would be putting guardrails in place so that you knew that what the agent/compiler was creating was what you wanted. Many years ago, that was binaries or bytecode packaged with lots of symbols for debugging. Today, that's more automated testing.
"You have to assume that any work done outside classroom has used AI."
That is just such a wildly cynical point of view, and it is incredibly depressing. There is a whole huge cohort of kids out there who genuinely want to learn and want to do the work, and feel like using AI is cheating. These are the kids who, ironically, AI will help the most, because they're the ones who will understand the fundamentals being taught in K-12.
I would hope that any "solution" to the growing use of AI-as-a-crutch can take this cohort of kids into consideration, so their development isn't held back just to stop the less-ethical student from, well, being less ethical.
11% success rate for what is effectively a spear-phishing attempt isn't that terrible and tbh it'll be easier to train Claude not to get tricked than it is to train eg my parents.
Roam has always felt like a bit of a chore -- while it's easy enough to set up backlinks, having to do that one step has always been like a waste of time to me. This is the kind of thing that imo an agentic workflow could do for you:
- Just start typing
- Let the LLM analyze what you're typing, given the RAG database of everything else you've added, and be able to make those kinds of correlations quickly.
- One-button approve the backlinks that it's suggesting (or even go Cursor-style yolo mode for your backlinks).
Then, have a periodic process do some kind of directed analysis; are you keeping a journal, and want to make sure that you're writing enough in your journal? Are you talking about the same subjects over and over again? Should you mix things up? Things like that would be perfect for an LLM to make suggestions about. I don't know if Roam is thinking of doing this or not.
Tesla is only in business today because it was able to sell carbon credits to other automakers. Take that government subsidy away and Tesla would have died in 2009.
[ my public key: https://keybase.io/mark242; my proof: https://keybase.io/mark242/sigs/nJ2IAh2nEXLlnolJOnWEDYJT48SvfBE0w9dqQoQ4d0Q ]