Jet_Xu

It depends on whether nowadays FLAG will still need engineer write code during interview.

You are right but it is not because the weakness of AI, it is because all AI generation app are built by those coder only know .md files. They do not know what a consultant level slides looks like.

See this demo in the middle I show some top level strategy business slides (they are all generated by AI) https://youtu.be/Sq3a5qxsLwM

I am also working on such tool :)

Try DocMason it is born for agentic analyze messy office files.

https://github.com/JetXu-LLM/DocMason

Demo video: https://youtu.be/Sq3a5qxsLwM

If you want to get knowledge from KB within 10 seconds, then traditional RAG (embedding+vector based) is still the most efficient way -- maybe more in consumer facing search / chat area.

If you want to get most precise and useful information from KB in minutes, then Agentic RAG is the key.

I believe Multimodal KB+Agentic RAG is a suitable solution for personal KB. Imagine you have tons of office docs and want to dig some complex topics within it. You could try https://github.com/JetXu-LLM/DocMason

Fully retrieve all diagram or charts info from ppt and excels, and then leverage Native AI agents(e.g. Codex) to conduct Agentic Rad

I pressed Hide, but still not work. And I do not have a "delete" button under this post. It is really awkward...

I am so sorry that I post two duplicate post in Show HN for same project

please just refer to this post with main content in the body (pure hand write content no AI generation ^-^): https://news.ycombinator.com/item?id=47640770

And could anyone help or tell me how to delete this post?

No, too harmful for my eyes...

What I want is markdown format support in Hacker news. But other features really not important :)

Please refer to my recent AI Code review performance test include DeepSeek V3: https://news.ycombinator.com/item?id=42547196

A few weeks ago, I shared LlamaPReview (an AI PR reviewer) here on HN and received great feedback [1]. Now I'm trying to understand how experienced developers prioritize different aspects of code review to make the tool more effective.

When you open a PR, what's the first thing you check? Is it:

- Overview & Architecture Changes - Detailed Technical Analysis - Critical Findings & Issues - Security Concerns - Testing Coverage - Documentation - Deployment Impact

I've set up a quick poll here: https://github.com/JetXu-LLM/LlamaPReview-site/discussions/9

Current results show an interesting split between "Detailed Technical Analysis" and "Critical Findings", but I'd love to hear HN's perspective:

1. What makes you trust/distrust a PR at first glance? 2. How do you balance between architectural concerns and implementation details? 3. What information do you wish was always prominently displayed?

Your insights will directly influence how we structure AI Code Review to match real developers' thought processes.

[1] Previous discussion: https://news.ycombinator.com/item?id=41996859

Interesting timing, considering China just launched an antitrust probe into Nvidia [1] and there were earlier reports about H20 order suspension [2]. This hiring push seems to be a delicate balancing act:

- Expanding autonomous driving R&D while navigating export controls - Maintaining Chinese market presence despite regulatory pressures - Building local expertise when H100/A100 sales are restricted

The automotive sector might be strategically chosen as it's less impacted by current chip restrictions. Worth noting that China remains Nvidia's largest market in Asia, accounting for ~20% of their revenue.

[1] https://www.reuters.com/technology/china-investigates-nvidia... [2] https://www.tomshardware.com/tech-industry/artificial-intell...

Interesting approach! While converting docs to markdown works, I've found that technical documentation (especially for complex repos) needs more than just text conversion for effective LLM consumption.

The key challenge is preserving repository context - like code dependencies, architectural decisions, and evolution patterns. Have others experimented with knowledge graph approaches for maintaining these relationships when processing repos for LLMs?

Interesting approach! While URL-based extraction is convenient, I've been working on a more comprehensive solution for repository knowledge retrieval (llama-github). The key challenge isn't just extracting code, but understanding the semantic relationships and evolution patterns within repositories.

A few observations from building large-scale repo analysis systems:

1. Simple text extraction often misses critical context about code dependencies and architectural decisions 2. Repository structure varies significantly across languages and frameworks - what works for Python might fail for complex C++ projects 3. Caching strategies become crucial when dealing with enterprise-scale monorepos

The real challenge is building a universal knowledge graph that captures both explicit (code, dependencies) and implicit (architectural patterns, evolution history) relationships. We've found that combining static analysis with selective LLM augmentation provides better context than pure extraction approaches.

Curious about others' experiences with handling cross-repository knowledge transfer, especially in polyrepo environments?

Interesting discussion! While RAG is powerful for document retrieval, applying it to code repositories presents unique challenges that go beyond traditional RAG implementations. I've been working on a universal repository knowledge graph system, and found that the real complexity lies in handling cross-language semantic understanding and maintaining relationship context across different repo structures (mono/poly).

Has anyone successfully implemented a language-agnostic approach that can: 1. Capture implicit code relationships without heavy LLM dependency? 2. Scale efficiently for large monorepos while preserving fine-grained semantic links? 3. Handle cross-module dependencies and version evolution?

Current solutions like AST-based analysis + traditional embeddings seem to miss crucial semantic contexts. Curious about others' experiences with hybrid approaches combining static analysis and lightweight ML models.

I'd like to share our technical journey migrating our code review system from Mistral-Large-2407 to 2411, and the key challenges we overcame. Here are the most interesting findings:

1. Prompt Pattern Evolution

  - Initial challenge: Direct model upgrade led to significant quality degradation
  - Root cause: Changes in 2411's prompt processing architecture
    # Previous prompt format for Mistral-Large-2407
    <s>[INST] user message[/INST] assistant message</s>[INST] system prompt + "\n\n" + user message[/INST]
    # New optimized prompt format for Mistral-Large-2411
    <s>[SYSTEM_PROMPT] system prompt[/SYSTEM PROMPT][INST] user message[/INST] assistant message</s>[INST] user message[/INST]
  - Solution: Implemented enhanced prompt patterns through LangChain

2. API Integration Insights

  - Built custom HTTP client interceptor for debugging
  - Discovered crucial differences in message formatting
  - Leveraged LangChain's abstraction layer effectively

3. Key Technical Improvements

  - Enhanced review focus through optimized prompts
  - Improved output reliability and format compliance
  - Eliminated response truncation issues

This is implemented in our AI Code Review Github APP LlamaPReview [https://jetxu-llm.github.io/LlamaPReview-site/]. Happy to discuss specific implementation details or share more technical insights about working with Mistral-Large-2411 in production.

Is that possible this bot could understand and remember all my history emails, and then conduct Agentic RAG before helping on reply?

I've been working on an AI-driven development vision, building on the "System of Agents" concept discussed in the article.

The key insight is that to achieve truly automated development, we need AI agents across the entire development lifecycle - not just in isolated tasks.

Our system implements a "Retrieval Augmented - Complex Coding Task accomplishment loop" with: - Multiple LLM-based agents handling different aspects of development - A Task and State Management System for agent coordination - Dual knowledge retrieval combining self-repository learning and GitHub public knowledge - Integrated development tools library (editing, testing, deployment) orchestrated through multi-agent collaboration

The key differentiator is the holistic integration - every step from initial development to deployment is agent-aware and interconnected. This creates a true "Service-as-Software" development environment where AI doesn't just assist, but actively drives the development process.

We're seeing promising results in automated code generation, self-healing test suites, and intelligent CI/CD pipelines that learn from deployment patterns.

Would love to hear thoughts from the community, especially from those working on similar full-lifecycle automation approaches.