software-engineering

Bilingual

Scaling Agentic RL: 365,000 Environments for SWE, Terminal, and Search
2 months ago
- Prime Intellect integrates 23 agentic tasksets (365,000+ tasks) across software engineering, terminal, and search domains into a unified API.
- The platform provides a single command for evals and RL training, with verifiers v1 decomposing environments into taskset, harness, and runtime layers.
- All tasksets are validated via gold-patch and no-op checks, with cleaned re-uploads and transparent exclusion lists to ensure reliable reward signals.
- Grading material is withheld from the agent until scoring time to prevent reward hacking, with future plans for isolated grading sandboxes.
- The project includes detailed breakdowns of SWE, terminal, and search tasksets, each with their own integrations and validation methodologies.
Writing a good design document
2 months ago
- Design documents are technical reports that outline implementation strategy with trade-offs and constraints.
- The goal is to convince the reader (and the author) that the design is optimal, akin to a mathematical proof.
- Good organization is crucial; avoid 'spaghetti design docs' by ensuring each sentence flows logically from the previous.
- Anticipate readers' objections and preemptively address them to guide their understanding.
- Edit ruthlessly to remove unnecessary words; aim to cut ~30% from the first draft without losing information.
- Practice extensively; Amazon's doc-writing culture (silent reading with red pen) forces improvement.
- Use short paragraphs with one idea per paragraph, allowing readers to compress information in short-term memory.
- Include an appendix for complex calculations or simulations, keeping the main body clean and accessible.
- Worked example demonstrates editing verbose text into a concise version conveying the same information.
On Long Term Software Development - Bert Hubert's writings
2 months ago
- Limit and carefully audit dependencies; avoid thousands of small dependencies.
- Invest heavily in testing to catch regressions from shifting dependencies and enable refactoring.
- Keep code simple and boring; refactor early and often to manage complexity.
- Document not only code but also design philosophy, rationale, and architecture.
- Maintain a stable, long-term team of employees rather than relying on consultants.
- Consider open-sourcing code to enforce higher standards and gain external scrutiny.
- Implement thorough logging and telemetry from the start for debugging and performance monitoring.
- Periodically review dependencies for changes, security issues, or new capabilities.
- Avoid hype-driven technology choices; prefer proven, long-lived solutions.
What does "playing politics" mean for software engineers?
3 months ago
- For software engineers, 'playing politics' does not involve scheming or making power plays; instead, it means understanding the organizational power dynamics to avoid pitfalls and align with company values.
- Key principles include: being aware of who holds power (typically senior management), avoiding making powerful enemies, helping powerful people proactively, and ensuring your contributions are visible to them.
- To navigate politics effectively: prioritize important projects, respond promptly to powerful individuals, support their narratives discreetly, and use technical expertise to influence implementation details without challenging grand strategies.
- Making powerful enemies can be career-ending, so it's crucial to pick battles wisely and disagree privately and politely, while quitting may be necessary if a senior leader dislikes you.
- Playing politics is ultimately about leveraging your role as a supportive contributor, not a decision-maker, to gain influence and protect your career within the company's existing structure.
Chasing new skills, going back to basics: how software engineers adapting to AI
3 months ago
- Matt, a software engineer, uses his four-hour train commute to work on a personal browser-based game to maintain his coding skills, as his job now involves reviewing AI-generated code.
- AI is transforming software engineering rapidly, with Google reporting 75% of its code is AI-written, causing anxiety and prompting engineers to adapt or consider leaving the industry.
- Over 600,000 US tech workers lost jobs since ChatGPT's release in 2022, and unemployment for computer science graduates rose to 7% in 2024, reflecting industry turmoil.
- Experts predict coding skills may decline in value, while the ability to evaluate AI-generated code becomes crucial, shifting focus to problem-solving and system design.
- Software engineers are exploring new roles, using AI to build skills, or organizing for collective action, as seen with resource centers like What We Will supporting tech workers.
- Enrollment in computer science programs dropped recently, and the profession's appeal is waning, with some engineers contemplating career changes like opening a food truck.
- AI's high operational costs may prevent full automation, leading to a balanced future where engineers work alongside AI rather than being replaced entirely.
Show HN: Hnwork.app – UI for Who is hiring posts
3 months ago
- A job board listing software engineering and related roles from July 2026, featuring 240 jobs across 10 pages.
- Positions include Senior/Staff Software Engineers, AI/ML Engineers, Backend Engineers, Full-stack Engineers, and specialized roles like Data Analysts and Product Managers.
- Jobs are offered in various work setups: Remote, On-site, and Hybrid, with locations spanning North America, Europe, and Asia-Pacific.
- Salaries are mostly not listed, but some roles specify equity or ranges like $120k-$190k or $240k-$260k.
- Common technologies and skills required include Java, Python, Go, Rust, TypeScript, AI/LLM, AWS, GCP, and cloud platforms.
Canonization and the Overhang
3 months ago
- David Bessis argues that mathematics overvalues theorem proving while undervaluing creativity, clarity, and teaching, which are critical for progress.
- LLM-powered theorem provers can prove theorems without the beneficial side effects of human collaboration and intuition.
- In software, there's a parallel between code that passes tests and code that is socially constructed for team usability and iteration.
- Canonization is the process of turning one-off solutions into reusable, coherent, and compatible systems or libraries, which is time-consuming but essential for long-term value.
- Software benefits from canonized code through stable abstractions and reliable systems, contrasting with disposable, single-use software that may seem 'bad' by traditional standards.
- The Overhang refers to unrealized potential from past creativity, where connecting existing ideas can yield new solutions, a concept applicable to both mathematics and software.
- LLMs are well-suited for searching the Overhang by memorizing and pattern-matching across large corpora, unlike humans who rely on intuitive leaps.
- Open source software represents an Overhang of canonized work that can be built upon for future development.
- Valuing only theorem proving or coding without canonization and knowledge transmission risks depleting the Overhang and undervaluing critical 'glue work' like cleanup and teaching.
Show HN: QUALITY.md – open format/specification, agent skill, and CLI
3 months ago
- QUALITY.md is an open file format for declaring a project quality model, including quality characteristics, requirements, and context.
- It aims to align stakeholders on what matters most, identify impactful improvements, and build agentic control loops for continuous quality maintenance.
- The format is agent, tool, and vendor agnostic, with companion tools like /quality agent skill and qualitymd CLI for evaluation and reporting.
- Key benefits include proactive quality management, tackling technical debt, and compounding learning at high leverage points.
- Usage involves setup, evaluation, and improvement phases to engineer quality loops, with the philosophy of caring for a thing to benefit others.
Engineering for Bounded Cognition
3 months ago
- The human mind can only hold about four separate items in working memory at once, much smaller than the software systems we build.
- Attention is narrow and unreliable, as shown by experiments like inattentional blindness (missing a gorilla) and change blindness (missing a swapped person).
- Software engineering must account for this 'bounded cognition' by designing systems that small, distractible minds (human or AI) can work on safely, using practices like clear naming, boundaries, testing, and undo functionality.
- Designing for constrained users (e.g., arthritic hands) often results in better tools for everyone, a principle that applies to software as well.
- Large language models exhibit similar cognitive limitations, such as limited context windows and reduced attention to middle inputs, mirroring human flaws.
Fintech Engineering Handbook
3 months ago
- Introduces the Fintech Engineering Handbook, a guide on patterns for building money-handling software.
- Targets fintech newcomers, practitioners, and outsiders to explain trustworthiness in money systems.
- Core principles: No invented data, no lost data, no trust.
- Money representation: avoid floating-point; use arbitrary precision, minor-units, or rational numbers.
- Rounding strategies: explicit, business-decided, minimal; track residuals to avoid losing or inventing money.
- Currency handling: pair amount with currency; validate codes; treat crypto distinctly; pack in a Money type.
- FX rates: directional, time-sensitive; distinguish transactional vs reference rates; track source.
- Ledger uses double-entry bookkeeping: immutable entries, balances derived, accounts typed (assets, liabilities, equity).
- Timestamps: value time, booking time, settlement time; record all to preserve information.
- Audit trails: capture what, when, who, why; event sourcing as a systematic approach; immutability required.
- Reversals/corrections: post compensating entries; link to originals; consider reporting periods.
- Invariants enforced by construction, runtime checks, and post-factum verification.
- Funds reservation prevents double-spending; distinguish total vs available balance; requires strong consistency.
- Overdrafts: intentional (credit product) vs unintentional; handle explicitly, don't clamp to zero.
- Idempotency: use explicit keys; handle errors; validate payloads; ensure atomicity; test retries.
- Full resumability: persist flow state; resume stalled flows; each step idempotent; roll forward or compensate.
- External APIs: don't trust schema; expect failures; store requests/responses; consider provider redundancy.
- Webhooks: don't assume ordering, validity, or single delivery; acknowledge fast; verify caller; persist raw payload.
- Reliable notifications: use outbox, CDC, listen-to-yourself, or event sourcing; ensure at-least-once delivery.
- Reconciliation: compare systems; handle missing/different data; match heuristically; fix discrepancies properly.
- Controls: segregation of duties, four-eyes; record approvals; enforce least privilege; audit access changes.
- Change trail: use source control; enforce reviews and pipelines; trace deployments.
- Testing: property-based, invariant checks, generative idempotency, crash injection, round-trip, golden, backward-compatibility, production testing.
- Appendix A: Glossary of fintech terms (accounting, money/FX, transactions, payments, trading, custody, compliance).
- Appendix B: Example flows: crypto withdrawal, card deposit, in-app conversion with cashback.
- Appendix C: Author background, writing process, and intent as a living document.
Solid and Clean Code never felt solid or clean to me
3 months ago
- The author critiques the presentation and perceived manipulative nature of 'Uncle Bob' (Robert C. Martin)'s works like Clean Code and SOLID principles.
- He finds the content filled with unnecessary filler, akin to academic padding, and questions the subjective naming like 'Clean' or 'Simple' for code.
- The author argues that software engineering culture is dogmatic and overly reliant on acronyms (e.g., SOLID, DRY) that can lead to complexity rather than clarity.
- He draws parallels from his history studies, noting how writing styles and cultural rules form, and applies this to detect manipulative or overly subjective advice in programming.
- The critique is not about the technical ideas themselves but how they are marketed and perceived, emphasizing the need for more objective and substantive content.

software-engineering

Scaling Agentic RL: 365,000 Environments for SWE, Terminal, and Search

Writing a good design document

On Long Term Software Development - Bert Hubert's writings

What does "playing politics" mean for software engineers?

Chasing new skills, going back to basics: how software engineers adapting to AI

Show HN: Hnwork.app – UI for Who is hiring posts

Canonization and the Overhang

Show HN: QUALITY.md – open format/specification, agent skill, and CLI

Engineering for Bounded Cognition

Fintech Engineering Handbook

Solid and Clean Code never felt solid or clean to me