zen4ttitude

yeah this might have been contradictory... thanks for pointing it out. I will watch mirror reflections in the future.

You sit on the arbitrating layer. It sounds like you have some programming experience as you miss looking at the code. I did check a lot of code and got tired of how perfect it were, generated by AI. Latest Claude is insane, does not even make errors. You still have to guide it and it will occasionally go astray and make rookie mistakes. If you extrapolate to 6 months down the road, one Claude API = a team of 10 programmers. None of them sloppy and undocumented. So if one wants to remain pertinent in this new economy of infinite coding, one should go back to project management, learn best practice and software fundamentals. I think there will be a lot of demand for ex-programmers able to steer AI in the most efficient stack, the best architecture and the most optimised deployment. Notions of recurring cost, maintenance and security will help for sure.

Does anyone know more about the benchmark? 60% accuracy gets a drumroll? How would Claude do? How would a human do? I tried the previous version and was not impressed. I went back to Claude that is very hard to beat, and versatile with context enrichment.

For complex tasks I ask ChatGPT or Grok to define context then I take it to Claude for accurate execution. I also created a complete pipeline to use locally and enrich with skills, agents, RAG, profiles. It is slower but very good. There is no magic, the richer the context window the more precise and contained the execution.

I built ACF (AgentCodeFactory but open-source/MIT) because I got tired of sending code to cloud APIs and wanted a structured, local way to run multi-agent workflows for coding tasks. It's a pipeline that runs entirely on your machine (Ollama, LM Studio, or API keys if you want), where you can compose and share extensions like agents, skills, profiles, and RAG sources.

Quick example: acf run "Add login rate-limiting to my FastAPI app"

Under the hood it's a 7-stage pipeline (Spec → Context gathering → Design → Implementation → Testing → Docker validation → Verification). Each stage feeds artifacts to the next, with optional human approval gates before anything risky (auth changes, secrets, etc.) gets committed. Every run creates a git branch with commits for each iteration—so you can diff, resume, or rollback easily. Key bits I find useful:

Routes tasks to different models based on needs (small one for summaries, code-specialized for generation, embedding for RAG). YAML policies for enforcement (e.g., block secrets, require >80% coverage, flag payment-code changes). RAG over your codebase so agents actually understand patterns, not just grep. Marketplace for extensions: someone writes a great security scanner skill or React profile with best practices → publish once, others install and plug in.

Why local? My code (especially proprietary stuff) stays mine. Modern local models (Qwen, Mistral variants, CodeLlama) handle most stages surprisingly well when you split work into focused agents instead of one giant prompt. The marketplace is live (though sparse), and extensions include context estimates so you know if it'll fit your hardware/model.

Current state: the core pipeline works reliably on my setup, but it's still early—one person can only test so much. Vision includes self-improving loops (learning from retry failures), configurable stages (skip Docker if you don't need it), shared policy packs for teams, and way more community extensions.

I'm looking for:

People running local models who want to stress-test with different sizes/backends Folks who've built code-review/transform agents/skills that could become extensions Security-minded people to poke at the policy system and scanners Anyone with ideas on making pipelines more composable or self-healing

Quick start (Python 3.11+, Ollama running): git clone https://github.com/Tennisee-data/acf.git cd acf pip install -e ".[dev]" acf run "Add login rate-limit" Repo: https://github.com/Tennisee-data/acf Happy to dive into the agent routing, policy engine, how the git integration works, or why I think shared local extensions could be a game-changer for offline/dev privacy workflows. What do you think—useful? Missing pieces? Fire away.

(And yes, it's possible to monetize more advanced/complex extensions if someone wants to support ongoing work, but that's secondary—the focus is open collaboration.)

It started as a tongue in cheek project. Now I think there is a definite case to be made for local AI as a movement. It's all about privacy sure. It's also about OpenSource roots. I think it might have to do with convenience in a controlling the entire pipeline kinda way. Finally, there is something inefficient about having these behemoth data centers to build an API... What do you think about keep it local if you can? The environment cost of AI?

I think this is the future as well, running locally, controlling the entire pipeline. I built acf on github using Claude among others. You essentially configure everything as you want, models, profiles, agents and RAG. It's free. I also built a marketplace to sell or give away to the community these pipeline enhancements. It's a project I wanted to do for a while and Claude was nice to me allowing it to happen. It's a work in progress but you have 100% control, locally. There is also a website for those not as technical where you can buy credits or plugin Claude or OpenAI APIs. Read the manifesto. I need help now and contributors.

What I find surprising is how much human intervention the creator of Claude uses. Every time Claude does something bad we write it in claude.md so he learns from it... Why not create an agent to handle this and learn automatically from previous implementations. B: Outcome Weighting

  # memory/store.py
  OUTCOME_WEIGHTS = {
      RunOutcome.SUCCESS: 1.0,    # Full weight
      RunOutcome.PARTIAL: 0.7,    # Some issues but shipped
      RunOutcome.FAILED: 0.3,     # Downweighted but still findable
      RunOutcome.CANCELLED: 0.2,  # Minimal weight
  }

  # Applied during scoring:
  final_score = score * decay_factor * outcome_weight

  C: Anti-Pattern Retrieval

  # Similar features → SUCCESS/PARTIAL only
  similar_features = store.search(..., outcome_filter=[SUCCESS, PARTIAL])

  # Anti-patterns → FAILED only (separate section)
  anti_patterns = store.search(..., outcome_filter=[FAILED])

  Injected into agent prompt:
  ## Similar Past Features (Successful)
  1. "Add rate limiting with Redis..." (Outcome: success, Score: 0.87)

  ## Anti-Patterns (What NOT to Do)
  _These similar attempts failed - avoid these approaches:_
  1. "Add rate limiting with in-memory..." (FAILED, Score: 0.72)

  ## Watch Out For
  - **Redis connection timeout**: Set connection pool size

  The flow now:
  Query: "Add rate limiting"
           │
           ├──► Similar successful features (ranked by outcome × decay × similarity)
           │
           ├──► Failed attempts (shown as warnings)
           │
           └──► Agent sees both "what worked" AND "what didn't"

Agree, I developed a 150K line stock analytics Saas that started with the will to provide my son with some tools to analyse stocks.

I enjoyed this experience of CLI coding so much that I developed Market Sentiment parsing 300,000 business articles and news daily, a dividend based strategy with calendar of payouts and AI optimised strategies to extract every drop of interest, an alert system for a strategy you backtested in the playground and its key triggers are tracked automatically so you can react, an ETF risk analysis model with external factors, all quant graphs and then some, time models with Markov, candlestick patterns, Monte Carlo simulation, walk forward and other approaches I had learned over the years. There is much more.

I know you don't measure a project in terms of lines of code, but these are optimised, verified, tested, debugged and deployed. There are so much features, because I was having fun and got carried away. I'm semi-retired and this is like having my web agency back again.

I used to program in GRASP... I have a data scientist certification, did a lot of Python, Machine Learning, NLP, etc. I really enjoy the prompt based development process as it seems like you are reaching the right resource for your question from a staff of experienced dev. Of course you need to check everything as a junior dev always creeps in when you least expect it. Especially for security. Discuss best practices often and do your research on touchy subjects. Compare various AI on the same topic. GROK has really caught up. OpenAI has slowed down. CLAUDE is simply amazing. This AI thing is work in progress and constantly changing.

I have a noticed an amazing progression over the past year. I have a feeling their models are retrained, tweaked on our interactions even if you asked for them not to use the data. The temptation is too high and the payoffs abound in this market for the best AI tools.

I'm building a code factory now with agents and key checkpoints for every step. I want to remove human intervention from multiple sub steps that are time consuming so I can be even more productive in 2026...

Most people now conduct searches through AI chat. We never trusted Google with our search terms, IP address linked to WiFi and cell towers surveys with Google trucks for cross referencing on Google map, browser fingerprinting, time of day pattern detection, mouse reaction time measurement for age estimation, cross referencing with economic profiling of neighbourhoods, income bracket estimation algorithms, interest profiling based on search terms, browsing breadcrumbs, social network tracking, etc. Now imagine the new powers of AI chat adding reasoning patterns, deep thinking and complete trust to the equation. Let us organise a disconnect day where you turn off your phone and Internet router and ISP box just to confuse the algorithms! Where do we go from here? We stay home and invite disconnected friends for a rare moment of statistically insignificant privacy.