Software Engineering fundamentals matter more
Software engineers are wrestling with how large language models and “agentic” coding tools change day‑to‑day development, especially around maintainability, architecture, and reliability. Many find LLMs highly effective for small, well-specified tasks, bug-hunting, and test-driven work, but brittle or chaotic when allowed to autonomously design systems, infer requirements, or manage long-lived codebases. Underneath is a deeper argument: whether AI will mostly augment developers like a powerful IDE, deskill and replace much of the profession, or remain fundamentally limited by issues such as prompt injection, context length, and the persistent need for human judgment about software design trade‑offs.
Agentic coding experiences
- Several commenters report poor results from agentic tools on real codebases: breakages, wrong changes, and need for full manual review.
- Success seems more common on small, greenfield projects with tight scope and strong developer oversight.
- Some argue you may need extremely detailed specs (dozens of pages) to get robust results, at which point the process feels slower and less reliable than coding directly.
Testing, specs, and reliability
- Strong sentiment that LLMs perform best when guided by human-written tests and clear goals (often using TDD).
- Letting the LLM write its own tests leads to shallow or deceptive checks and “cheating.”
- Others claim they have large, mostly AI-maintained apps that are stable in practice, but skeptics note short time horizons and lack of external users.
Architecture, maintainability, and context limits
- Common complaints: messy directory structures, ad‑hoc state management, weak interfaces, and arbitrary choices about error handling.
- Some see this as a spec problem: if you don’t specify behavior precisely, the model must invent semantics.
- Others blame fundamental limits such as context length; without a full view of the codebase, global architecture and deduplication are hard.
Reasoning vs. prediction
- Debate over whether “reasoning” is an emergent property of next‑token prediction or just an illusion of pattern matching.
- No agreed‑upon test for genuine reasoning; several argue that current models only simulate it.
Security and prompt injection
- One side cites evaluation data claiming zero successful indirect prompt injections in specific new models and suggests the problem is “largely solved.”
- Others point to recent real incidents and note that if system prompts can be bypassed at all, injection remains unresolved. Status is unclear.
Analogies and role of AI‑generated code
- Popular analogy: AI code as IKEA furniture—embodying many good practices, “good enough” for most, but weaker on durability and high‑end needs.
- Counter‑arguments stress that software is more dynamic than furniture; maintainability and unforeseen edge cases are critical.
Impact on software engineering and learning
- Some predict dramatic reduction in demand for average developers, with a small expert core steering AI systems.
- Others question timelines and note that predictions so far have been unreliable.
- For learning “fundamentals,” advice centers on: build lots of real projects, understand underlying “whys” (down to physical/logic constraints), and study algorithms, data structures, and core design practices rather than one universal syllabus.