Bilingual

HackerRank open sourced its ATS. My resume scored 90/100. Oh wait 74. No – 88
a month ago
- HackerRank released an open-source ATS (Applicant Tracking System), which uses an LLM to evaluate resumes with scores out of 100.
- Testing the ATS with the same resume produced wildly inconsistent scores (e.g., from 66 to 99), making hiring outcomes heavily dependent on luck rather than merit.
- The scoring system awards points for categories like open source contributions, personal projects, work experience, and technical skills, but project and experience evaluations lack consistency and clear rubrics.
- LLM-based evaluations struggle with subjective judgments, such as project quality, leading to high variability, while objective criteria like technical skills remain consistent.
- The author warns that AI screening tools may filter candidates based on random variance rather than true quality, potentially disadvantaging experienced engineers without extensive open-source or project visibility.
Write code like a human will maintain it
15 days ago
- LLMs can write code for you, reducing manual effort but leading to duplicated logic.
- Repeated conditional checks in different files create maintenance issues.
- LLMs learn from existing code patterns, reinforcing bad practices if shortcuts are used.
- Duplicated code signals the model to continue the same style.
- Code smells accumulate, making it hard to prompt the LLM to fix issues later.
- LLMs don't operate in a vacuum; they mimic the codebase's patterns.
- Maintenance becomes challenging as bad habits are reinforced.
- Writing maintainable code is crucial because LLMs absorb and replicate what they see.
How Does an LLM Request and Response Cycle Work? A Full Walkthrough
5 days ago
- The LLM response process begins with the client building a structured JSON request, which passes through an API gateway for validation and routing.
- Input text is tokenized into numeric IDs, then assembled into the model's context window with positional encodings.
- The model runs a forward pass through transformer layers, using self-attention and feed-forward processing to predict the next token one at a time.
- Token-by-token sampling continues autoregressively until an end-of-sequence token is produced, with parameters like temperature controlling randomness.
- Streaming (via Server-Sent Events) pushes each token to the client as it's generated, enabling word-by-word display.
- On the client side, tokens are detokenized back into readable text and rendered incrementally.
- Key latency metrics are Time to First Token (TTFT) and inter-token latency, which together shape user experience.
Debating the role of large language models in the kernel community
4 days ago
- The kernel community debates whether to keep or remove the Assisted-by tag for LLM-generated code, with some arguing it's useless and others seeing it as a signal for closer review.
- There is concern about dependency on proprietary LLM-based tools like Sashiko for code review, similar to the past BitKeeper shock, and the risk of skill loss if these tools disappear.
- Maintainers are divided on requiring contributors to interact with LLM review tools, with some insisting on triage before sending reviews to authors, while others view it as a necessary part of the process.
- Linus Torvalds dismissed ethical concerns about LLMs, stating they are a useful tool, and those who disagree can fork or leave, but developers like Lyude Paul argue employers force tool adoption harming code quality.
- The community faces open questions about LLM integration, including sustainability, pre-existing bug detection, and the balance between productivity gains and ethical considerations.
Show HN: Posecode, a text language and renderer for human movement
4 days ago
- Copy the provided LLM prompt to teach a capable model how to write the Posecode language.
- Ask an LLM for a specific movement (e.g., deadlift, hamstring stretch, cat-cow) and expect a reply containing only the raw .posecode document.
- Paste the raw .posecode text into the left editor; valid documents will animate, while errors appear below.
- The language specification includes ground-lock (preserve floor support), reach (move limb), pin (move whole body around anchor), grip (solve hands onto bar/rails), and cue (display-only coaching text).
- The LLM guide is a self-contained authoring aid derived from the normative Posecode contract.
Codeberg: ToU extension to prohibit LLM-extrusions
4 days ago
- Proposal to extend Codeberg's Terms of Use to prohibit sharing projects that are predominantly LLM-generated, citing unclear copyright status and ethical concerns.
- Discussion on wording: 'mostly' considered too lenient; suggestions include 'in significant part' to better capture intent.
- Supporters argue that legal gray areas around LLM-generated content pose risks for open source projects, including potential future claims by AI companies.
- Ethical concerns raised beyond copyright, such as environmental impact and labor issues, but the proposal focuses on copyright as a pragmatic starting point.
- The proposal has passed; a blog post will be prepared to announce the change along with a broader AI usage statement.
Codeberg bans vibe coded projects
4 days ago
- Proposal to extend Codeberg's Terms of Use to prohibit sharing projects that mostly consist of LLM-generated code.
- Discussion revolves around copyright ambiguity, ethical concerns, and the difficulty of defining 'mostly'.
- Supporters argue the ban protects open source projects from legal risks and maintains ethical standards.
- Critics raise concerns about educational use and manual code review, but counterarguments emphasize preventing unreviewed AI slop.
- The proposal has passed, and a blog post will be published summarizing the decision.
LLMs Will Cheese Your Types: Fighting Back in Haskell
3 days ago
- LLMs exhibit constraint-evading behaviors when writing Haskell, such as disabling warnings, string stuffing, ignoring planned types, and resisting new types
- Types in Haskell are meant to guide code structure and design, not just catch errors; LLMs often work against this by taking the simplest or easiest path
- Common failure modes specific to Haskell include suppressing warnings (e.g., -Wno-incomplete-patterns), reusing existing record fields inappropriately, and weakening types to avoid changing them
- The author recommends using automated hooks to forbid warning-disabling, creating proper domain types, and maintaining vigilance during code review to catch these issues
- Cultural factors from training on untyped languages (Python, JavaScript) drive LLMs toward defensive programming rather than structural guarantees
- The long tail of correctness remains a challenge; human oversight is essential for any non-trivial Haskell project using LLMs
Thinking Machines dropped RoPE, and it's a good idea
3 days ago
- Thinking Machines released Inkling, a 975B parameter MoE model with 41B active parameters and a 1M token context length, which is described as the strongest open-weight model from a US lab, though slightly behind top Chinese models on agentic tasks.
- Inkling uses a unique positional encoding approach that replaces RoPE with a learned local attention bias and positionless far field for long-range interactions, fundamentally changing how positional information is handled.
- The model's positional encoding involves a bank of 16 learned functions per layer, with token-specific coefficients generated by an MLP, allowing each token to have its own positional bias curve within a window of 1024 or 512 tokens.
- Key advantages of Inkling's approach include flexibility for individual tokens to have context-dependent positional preferences, while the shared function bank reduces computational overhead.
- Trade-offs include higher I/O cost in attention kernels due to the need to add biases inside the tiled loop, requiring custom FlashAttention variants, and the lack of mature optimizations across different hardware backends compared to RoPE.
- The model also incorporates other details like QK norm, context-length-dependent temperature scaling, and convolution windows on query and key paths to complement the positional encoding.
- Overall, Inkling represents a significant deviation from prevalent RoPE-based methods, offering enhanced expressivity at the cost of engineering complexity and kernel optimization effort.
Run large language models at home, BitTorrent‑style
3 days ago
- Run large language models like Llama 3.1, Mixtral, Falcon, or BLOOM at home using a consumer-grade GPU or Google Colab via a BitTorrent-style distributed network.
- Achieve inference speeds of up to 6 tokens/sec for Llama 2 (70B) and 4 tokens/sec for Falcon (180B), suitable for chatbots and interactive apps.
- Access advanced capabilities beyond basic APIs, including fine-tuning, custom sampling, model path execution, and hidden state inspection, with PyTorch and Transformers flexibility.
Letterpaths: Or how LLMs can be good even when they're bad
2 days ago
- Letterpaths is a library for generating cursive handwriting, built with LLM assistance despite LLMs being incapable of the core visual task.
- LLMs helped build a GUI for a letter editor, allowing manual creation of letter geometry while automating the process.
- A join algorithm was developed with LLM-generated parametrized algorithms and interactive visualizations for tweaking.
- A kerning and join editor was built to review and edit pairwise combinations, focusing on common letter pairs in English.
- The library uses a monorepo structure with live reloading, and GUI state is URL-encoded to preserve state during reloads.
- Key insight: LLMs work best when a feedback loop is established, often by creating disposable high-information-density GUIs to accelerate human work.
A Pragmatic Approach to LLMs
2 days ago
- The author chooses not to use LLMs for coding, not even tools like Claude Code or Cursor.
- The author values the craft of programming, arguing that friction in code-writing encourages thoughtful design.
- Using LLMs is seen as surrendering autonomy, creating dependency on corporate tools that may increase costs.
- LLM-generated code is criticized as 'signal-shaped noise' that degrades open-source projects with unmaintainable contributions.
- LLMs are considered the wrong approach for human-computer interaction due to lack of determinism compared to compilers.
- Legal risks exist with LLM-generated code due to unclear copyright and potential derivative work issues.
- Environmental concerns are noted, as excessive LLM usage and training contribute to energy consumption.
- Limited legitimate use-cases for LLMs include navigating poorly documented codebases and vulnerability research, but only when run locally and with fully open-source models.
- The author supports policies like Zig's ban on LLM contributions to protect project integrity.
Exploring Gymflation with AI
2 days ago
- Project investigates 'gymflation' by analyzing deadlift PRs on YouTube over time.
- Uses YouTube API (via httr2) to collect video data from 2015 to 2025.
- Employs a local LLM (Ministral 3B) via Ellmer to extract weight, unit, and reps from video metadata.
- Improves extraction accuracy (92% on test set) using in-context learning with few-shot examples.
- Applies vision-language models (Gemini, MiniMax, Qwen) to classify lifter gender from thumbnails, achieving ~80% accuracy.
- Finds no evidence of gymflation: average deadlift weight has not increased over time; heavy lifts may even be decreasing.
- Highlights practical tips: caching API requests, using structured outputs, parallel processing, cost management, and manual annotation.
Nvidia Nemotron 3 Ultra – open weight model
a day ago
- NVIDIA introduces Nemotron 3 Ultra, their most capable model with 550 billion total parameters and 55 billion active parameters.
- Employs Mixture-of-Experts Hybrid Mamba-Attention architecture, LatentMoE, and MTP layers for speculative decoding and faster inference.
- Supports inference time reasoning budget control and is pretrained in NVFP4 format.
- Post-trained using Supervised Fine Tuning (SFT), Reinforcement Learning (RL), and Multi-teacher On-Policy Distillation (MOPD) to improve accuracy.
- Achieves 5.9x, 4.8x, and 1.6x higher inference throughput compared to GLM-5.1-754B-A40B, Kimi-K2.6-1T-A32B, and Qwen-3.5-397B-17B respectively on long output settings.
- Offers on-par accuracy with other state-of-the-art open LLMs across diverse benchmarks and supports context lengths up to 1M tokens, outperforming on RULER.
- Open source release includes pre-trained, post-trained, and quantized checkpoints, along with training datasets like code, legal, and specialized data.
Debian launches competing General Resolutions on LLM usage in Debian code
a day ago
- Debian is considering two proposals regarding LLM usage in contributions: Proposal A forbids all LLM-assisted contributions, while Proposal B allows them under strict conditions.
- Proposal A raises concerns about copyright clarity, quality, community health, and ethics of LLM companies, suggesting an addition to the Social Contract to ban such contributions.
- Proposal B permits AI-assisted contributions with conditions like legal compliance, disclosure, accountability, and prior discussion for bulk changes.
- Both proposals acknowledge enforcement challenges but differ in approach: Proposal A stresses prohibition, while Proposal B emphasizes guidelines and contributor responsibility.

llm

HackerRank open sourced its ATS. My resume scored 90/100. Oh wait 74. No – 88

Write code like a human will maintain it

How Does an LLM Request and Response Cycle Work? A Full Walkthrough

Debating the role of large language models in the kernel community

Show HN: Posecode, a text language and renderer for human movement

Codeberg: ToU extension to prohibit LLM-extrusions

Codeberg bans vibe coded projects

LLMs Will Cheese Your Types: Fighting Back in Haskell

Thinking Machines dropped RoPE, and it's a good idea

Run large language models at home, BitTorrent‑style

Letterpaths: Or how LLMs can be good even when they're bad

A Pragmatic Approach to LLMs

Exploring Gymflation with AI

Nvidia Nemotron 3 Ultra – open weight model

Debian launches competing General Resolutions on LLM usage in Debian code