Posts tagged "AI":
Hacker news AI coding experience analysis
I have been using and experimenting with AI coding tools heavily for the last 3 months or so since joining Legion Health as a Founding Engineer. I was somewhat skeptical and approached using AI with suspicion since ChatGPT came out. I use Emacs as my workbench and optimized my workflow around using it as a terminal multiplexer, which naturally fits with Claude Code that I use as my main programming assistant. Below is my simple setup that might benefit other fellow minimalist Emacs users.
(use-package eat :ensure t :config (setq eat-term-name "xterm-256color" eat-kill-buffer-on-exit t process-adaptive-read-buffering nil eat-term-scrollback-size 500000) (define-key eat-semi-char-mode-map [?\s-v] #'eat-yank) (define-key eat-semi-char-mode-map [?\C-c ?\C-r] #'k/eat-redisplay)) (defun k/eat-redisplay () "Fix eat flicker/flash and display funkiness" (interactive) (unless (derived-mode-p 'eat-mode) (error "Not in an eat-mode buffer")) (when (and (boundp 'eat-mode) eat-mode (boundp 'eat-terminal) eat-terminal) (let* ((process (eat-term-parameter eat-terminal 'eat--process)) (window (get-buffer-window (current-buffer)))) (if (and process (process-live-p process) window) (eat--adjust-process-window-size process (list window))))) (setq-local window-adjust-process-window-size-function 'window-adjust-process-window-size-smallest) (goto-char (point-min)) (redisplay) (goto-char (point-max)) (redisplay) (setq-local window-adjust-process-window-size-function 'ignore))
I start an eat shell and run:
cd ~/repos/project-x && claude
This is a fast moving landscape and I find following few points are extremely helpful in my workflow:
- Spend few minutes to gather up and feed context related to what needs to be done to Claude at the start of a session.
- Always ask to show a plan and instruct Claude for guidance if there multiple options for a solution.
- Provide a skeleton such as directory structure, file names, function names and signatures.
- Provide use case and acceptance criteria testing instructions.
On top of that, you need to make sure Claude has access to tools that enhances its ability to look up relevant information. To provide more balanced overview of the AI coding experience, I used a great data analysis tool for Hacker News called CamelAI. Below are the result that more or less resonates with my personal experience.
🏆 Top Stories by Engagement
- Claude 3.7 Sonnet and Claude Code (2,127 points) 🟢
- Overwhelmingly positive reception for AI coding capabilities
- Demonstrates Claude's dominance in the space
- Cursor IDE lockout policy problems (1,511 points) 🔴
- Major backlash against policy changes causing user cancellations
- Shows fragility of user trust in AI tools
- AlphaEvolve: Gemini coding agent (1,036 points) 🚀
- Google's advanced algorithm design agent
- High interest in autonomous coding capabilities
- "Enough AI copilots, we need AI HUDs" (964 points) 🎛️
- Forward-thinking discussion about UI evolution
- Community wants more integrated experiences
- Void: Open-source Cursor alternative (948 points) 🔓
- Strong demand for open-source alternatives
- Privacy and control concerns driving adoption
📊 Key Trends & Patterns
- 🎯 Claude Dominance in AI Coding
- Evidence: Claude 3.7 Sonnet (2,127 pts), consistent praise in experience stories
- Insight: Anthropic's Claude has emerged as the clear leader for serious coding work, with developers consistently praising its code quality and reasoning capabilities over competitors
- ⚡ Tool Fragmentation & User Frustration
- Evidence: Cursor problems (1,511 pts), multiple "stopped using AI" stories (365, 109 pts)
- Insight: Users are jumping between tools due to policy changes, reliability issues, and unmet expectations. No single tool has achieved universal satisfaction, leading to "tool fatigue"
- 🔄 The Productivity Paradox
- Evidence: "Anyone struggling to get value out of coding LLMs?" (345 pts), productivity studies showing mixed results
- Insight: Despite massive hype, many developers struggle to see concrete productivity gains. The "almost right" code problem creates hidden productivity taxes that offset benefits
- 🧠 Cognitive Dependency Concerns
- Evidence: "After months of coding with LLMs, I'm going back to using my brain" (365 pts)
- Insight: Growing concern about over-reliance on AI leading to skill atrophy and reduced problem-solving capabilities among developers
- 🏢 Enterprise vs Individual Experience Gap
- Evidence: Microsoft 365 Copilot disaster (602 pts) vs individual success stories
- Insight: Stark divide between enterprise rollout failures and individual developer successes. Enterprise context adds complexity that current tools struggle with
- 🔓 Open Source Alternative Movement
- Evidence: Void alternative (948 pts), Tabby self-hosted (366 pts)
- Insight: Strong demand for open-source, self-hosted alternatives driven by privacy concerns, cost considerations, and desire for control
🎯 Engineer Experience Patterns
- 🟢 Positive Experiences
- Who: Experienced developers using AI as an enhancement tool
- Patterns: Claude-based tools getting consistent praise, terminal-based tools popular with power users
- Benefits: Code generation, debugging assistance, learning new patterns
- Key Success Factor: Using AI to amplify existing skills, not replace them
- 🔴 Negative Experiences
- Who: Beginners over-relying on AI, enterprise users with complex requirements
- Patterns: Policy changes causing churn, productivity promises not materializing, "almost right" code creating more work
- Problems: Skill degradation, tool reliability issues, hidden productivity costs
- Key Failure Factor: Expecting AI to replace fundamental programming knowledge
- 🟡 Mixed Experiences
- Who: Pragmatic developers experimenting with different approaches
- Patterns: Tools working well for specific use cases, steeper learning curve than expected, context-dependent effectiveness
- Insight: Success heavily depends on matching use case, experience level, and realistic expectations
📈 Temporal Evolution (2024-2025)
- Early 2024: Initial hype phase - GitHub Copilot going free, new tool launches
- Mid 2024: Reality check phase - limitations becoming apparent, user frustrations mounting
- Late 2024: Maturation phase - Claude emerges as leader, tool fragmentation increases
- Early 2025: Sophistication phase - Claude 3.7/Code dominance, better understanding of limitations
- Mid 2025: Pragmatic phase - Focus on specific use cases, open-source alternatives, realistic expectations
🎯 Critical Insights for Engineers
- 💪 Skill Foundation is Critical
- AI tools amplify existing programming skills rather than replace them. Developers who understand fundamentals see the most benefit.
- 🎯 Context Matters Enormously
- Success depends heavily on use case, project complexity, and domain. There's no universal "AI coding works" or "doesn't work."
- 🔧 Tool Landscape is Rapidly Changing
- Claude-based tools currently leading, but the landscape shifts quickly. Expect to try multiple approaches.
- ⚠️ Cognitive Risks are Real
- Over-reliance can lead to skill degradation. Many successful developers use AI selectively while maintaining core problem-solving abilities.
- 📊 Productivity Benefits are Mixed
- Benefits exist but are often not as dramatic as promised. The "almost right" problem creates hidden costs that offset gains.
- 🏢 Enterprise Success ≠ Individual Success
- Individual developer success doesn't guarantee organizational success. Enterprise complexity creates additional challenges.
🔮 Future Outlook
- 🎯 Specialization: Tools becoming more domain-specific and context-aware
- 🤝 Hybrid Workflows: Combination of AI assistance and traditional coding becoming the norm
- 🔬 Better Metrics: More sophisticated ways to measure actual productivity impact
- 🎓 Education Evolution: Teaching AI-assisted development as a core skill
- 🔓 Democratization: More open-source and self-hosted options emerging
- 🎛️ UI Innovation: Moving beyond copilots to more integrated experiences (AI HUDs)
🔍 Specific Tool Performance
- 🥇 Claude: Clear winner for code quality, reasoning, and complex tasks
- 🥈 Cursor: Popular but plagued by policy and reliability issues
- 🥉 GitHub Copilot: Solid mainstream choice, good accessibility for beginners
- 🔓 Open Source (Void/Tabby): Rising alternatives for privacy/control-conscious developers
- ⚠️ Enterprise Tools: Microsoft 365 Copilot struggled badly in enterprise rollouts
💡 Bottom Line
- The AI coding experience is highly polarized - it works exceptionally well for some developers in specific contexts, but fails to deliver promised productivity gains for many others. Success requires:
- Matching the right tool to the right use case
- Maintaining realistic expectations
- Preserving core programming skills
- Understanding tool limitations
- Being prepared to adapt as the landscape evolves
Google Bard and Emacs
After reading a Google blog post on Bard's increasing ability for reasoning about source code, I thought I would give it a try. The issue is that not like OpenAI, Bard currently does not have an http API that I can use via curl. I googled around and came across the `bard-rs` project here: https://github.com/Alfex4936/Bard-rs. So I followed the excellent instruction to get set up using bard from command line and its is pretty solid. I used following Elisp to use `bard-rs` from Emacs' compilation buffer here:
(defun kcompilation-start (cmd name &optional mode) (let* ((compile-command nil) (compilation-save-buffers-predicate 'ignore) (compilation-buffer (compilation-start cmd (if (equal mode 'read-only) nil t) (lambda (m) (or (when (boundp 'name) (format "*%s*" name)) (buffer-name)))))) (when current-prefix-arg (with-current-buffer compilation-buffer (switch-to-prev-buffer (get-buffer-window (current-buffer))))) (message (format "Running %s in %s ..." cmd name)))) (defun kprompt-bard (&optional p) "Prompts for input to send it to `bard` using `bard-rs` in *bard-prompt* buffer. If mark-active, uses the text in the region as the prompt" (interactive "P") (let* ((bs "bard-prompt") (bname (format "*%s*" bs)) (bname (if (get-buffer bname) bname (progn (kcompilation-start "bard-rs -e ~/.env" bs) bname))) (prompt (if mark-active (replace-regexp-in-string "\n" "" (buffer-substring-no-properties (region-beginning) (region-end))) (read-string "AI Chat Prompt: ")))) (with-current-buffer (pop-to-buffer bname) (when p (end-of-buffer) (insert "!reset") (comint-send-input) (end-of-buffer) (insert prompt) (comint-send-input)) (when (not p) (end-of-buffer) (insert prompt) (comint-send-input)))))
You can bind `kprompt-bard` to any key of your choice and start interacting with Google bard from the comfort of Emacs' buffer.
AI or not to AI
1913 Webster dictionary gives following definition to Artificial Intelligence: Artificial - 1. Made or contrived by art; produced or modified by human skill and labor, in opposition to natural; 2. Feigned; fictitious; assumed; affected; not genuine. 3. Artful; cunning; crafty. 4. Cultivated; not indigenous; not of spontaneous growth; Intelligence - 1. The act or state of knowing; the exercise of the understanding. 2. The capacity to know or understand; readiness of comprehension; the intellect, as a gift or an endowment. 3. Knowledge imparted or acquired, whether by study, research, or experience; general information. Specifically; (Mil.) Information about an enemy or potential enemy, his capacities, and intentions.
Let us read and re-read above definitions and give it a few minutes to sink in. With our skilled labor, we have managed to produce a very powerful fictitious software that can understand, produce and reason about human generated artifacts such as language, images and videos. Our ability to make it more scalable, more accurate and more controllable is just a matter of time considering what we have is already pretty powerful enough. My following interaction with ChatGPT 3.5 is already impressive:
[ME]: Explain, then add tests and simplify if possible: (defun kprompt (&optional p) (interactive "P") (let* ((bname (if p "*org-ai-on-region*" "*scratch*")) (directive "Explain, then add tests and simplify if possible:\n") (prompt (if p (buffer-substring (region-beginning) (region-end)) (read-string "AI Chat Prompt: ")))) (with-current-buffer (pop-to-buffer bname) (when p (erase-buffer) (org-mode) (setq truncate-lines nil) (setq word-wrap t) (org-ai--insert-created-timestamp) (insert "\n") (insert "#+begin_ai\n" "[ME]: " directive prompt "\n" "#+end_ai\n") (forward-line -1) (org-ai-complete-block)) (when (not p) (beginning-of-buffer) (open-line 2) (org-ai-prompt prompt))))) [AI]: This function takes an optional argument, p, which determines whether the user will be prompted to enter a text or whether the function will use the text highlighted in the buffer. If p is provided, it will create a new buffer with the name "*org-ai-on-region*" and insert the highlighted text from the current buffer along with a directive. This new buffer buffer will be formatted using org-mode to allow for better organization of comprehension text. Finally, it will call org-ai-complete-block to add some AI-generated text to the prompt. If p is not provided, it will prompt the user to enter text and then call org-ai-prompt org-ai-prompt to add some AI-generated text to the prompt. Tests: Input: (kprompt) Expected Output: AI Chat Prompt: Input: (kprompt t) Expected Output: *org-ai-on-region* buffer created with prompt Input: (Highlight "This is a test") (kprompt t) Expected output: *org-ai-on-region* buffer created with "This is a test" text and AI-generated text. Simplified Code: The code appears to be relatively straightforward and efficient. No simplification is needed.
It understood and reasoned about a piece of code (simple for now but does not matter as it can get pretty powerful in no time) despite the fact that it has never seen above code before in its entirety (I am pretty sure about that since it is a private code and this is the only time I am making the code public). This degree of intelligence codified into a software that a few powerful cooperation currently dominates should be something that keeps every software engineers awake at night. Not because of its inherent danger or tremendous productivity boosting ability as folks on the opposite side of spectrum of current AI debate claimed, but because of the very fact that every aspect of human lives will be effected by a such a powerful code like ChatGPT whether we like it or not, and we need to do whatever we can to ensure it is used for the good of humanity in general. It is created by humans and should serve humans. Make no mistake about it. Powerful software systems like that is already used by big cooperations and rouge states to cajole people into a state of self censorship if not into a state of heedlessness of its future implication. Social media, powerful tracking and image recognition systems are already pervasive in the lives of millions of people that are being controlled by dictators all around the world (and it is being exported very actively in the name of economic progress) to socially engineer people's behaviors that benefits their agenda in the name of social and economic progress at the very expense of destroying anyone or anything that is deemed as an obstacle.
As a software engineer who have seen the worst of what bad actors can do with such a powerful systems, I am calling out to all of my fellow engineers to start thinking about what kind of world we would like our kids to inherit from us regardless of where you are, who you are and what is your geopolitical affiliation is. The wave is already there, and it takes all of us to make sure we are not being social engineered out of our humanity. I believe in the power of our humanity to make AI to work for us not the other way around. I registered the domain www.codeforhumanrights.org few years ago and this might be a good time to start putting it to a good use. If you are reading this and feel the need to start doing something, reach out to me via ktuman at acm dot org.