Advertisement
Advertisement
⚡ Community Insights
Discussion Sentiment
84% Positive
Analyzed from 1951 words in the discussion.
Trending Topics
#skills#team#github#https#tools#things#code#more#com#skill
Discussion Sentiment
Analyzed from 1951 words in the discussion.
Trending Topics
Discussion (39 Comments)Read Original on HackerNews
It seems like it was added in commit 74f317d at 11:06 UTC today, with five new hidden files being added under .claude and .vscode that together seem designed to either a) autorun a vscode tasks.json entry, or b) run a Claude session start hook, that will execute a large obfuscated payload. The payload looks like it will fingerprint your system and try to exfil your GitHub tokens.
Edit:
- It also exfils your AWS credentials (~/.aws/credentials, ~/.aws/config), named AWS profiles, and AWS secret managers and SSM parameter store contents
- Same with K8s secrets, with specific searches for GitHub and npm tokens, AWS keys, GCP keys, Azure keys, Stripe keys, Slack tokens, and Twilio keys
- Same with HashiCorp vault contents
- It will try to use your GitHub tokens (if they have the workflow permission) to run actions on your repository and try to exfiltrate secrets from there
- It will try to read a whole bunch of files from your local environment. I didn’t manage to extract the exact file list, unfortunately.
- If the normal C&C server is not available, it tries to create / select a GitHub repo, and commits your data as results-*.json files 100kb at a time
- It also has a bunch of stealth and persistence measures that I’m not qualified to really analyze. Don’t assume that deleting the files is necessarily enough.
Rotate your keys, folks.
EDIT: https://www.aikido.dev/blog/keyv-and-friends-compromised-in-...
never ever trust a skill especially in an age where its possible to bot submissions on HN (very easy to farm and create voting rings now with AI)
unfortunately this proves that Dang's work has limits, wouldn't be surprised if we've already been seeing manipulation of HN front page for quite some time now
try a fresh coding session without skills, agents.md, system prompt and additional tools
I think you will be positively surprised how good current models like GPT 5.6 Sol are when they are not oversteered and context spammed
Here is a task (python templating) with 9 runs with OpenCode, Pi and smol
https://smolenv.com/t/nested-template-includes-60636/
you can read each run step by step and see what the agents are doing and how the system prompt and available tools are steering their behaviour to take longer and higher cost
(disclaimer: I'm working on smol)
You can always backup your old instructions / memories. Personally I try to be hands-off with rules and very simple.
(it has way less context spam, fewer tools and smaller system prompt than the usual suspects)
databricks also looked at this: https://earendil.com/posts/pi-autoresearch-and-databricks/
actually the opposite: they matter a lot because they do steer the agent
with great power comes great responsibility
Creating a robust enough setup that can work on different models or different versions of a model is critical.
even with a robust, well thought through setup every model behaves in its own way, some adhere more to a system prompt, another model has more recent cut-off time and knows about new parts in the stdlib
some oversteer, some understeer …
if you want the best performance unfortunately there is not really a way other than to constantly adapt the harness/clutches/context to the model du jour
In a non-deterministic world the compiler is no longer consistent anyways.
Things like ArchUnit, static analyzers, and other deterministic tools can help with lower level things like architecture. For higher up stuff, I am increasingly feeling like agents don't guarantee anything and in many cases its just the opposite. This is where a thoughtful engineer and reviewer can keep things in check.
It's possible I'm off base here, but I can't make heads or tails of the LLM written readme.
1: https://arxiv.org/html/2510.05381v1
For example, I’m working on a project to remake the Final Fantasy XI client. My repository has a bunch of git submodules that reference other peoples’ related efforts, and an open source server. For example, despite including CLAUDE.md to suggest otherwise, Claude Code always ends up writing these insanely dense comments referring to specific files and lines of code in submodules. When those submodules update, now the comments are no longer correct.
So I added a hook to detect when comments are included. Then, for example, I have a deterministic heuristic and script involved to remove some kinds of comments, and another that asks Haiku to quickly LLM-as-a-judge whether or not to edit/remove the comment.
Similarly, I have a stop hook that reminds Claude to commit its code logically on main, noting that other changes may have been added by other concurrent sessions (I avoid worktrees and even branching for this particular project and stage of development.) It works well.
This is far from perfect but we're in this weird transition phase where none of the major AI tool providers are really focusing much on team use of their stuff. But I expect that will start changing soon.
Current tools mostly focus on individuals doing things in isolation. And of course in a team there's more to collaborating than throwing stuff at each other via github. A central repository of company skills is merely our way of improvising a solution.
I find it interesting that Anthropic hired a few of the key people behind Zulip recently. Team chat with tightly integrated AI tools could be a missing piece here. Team communication flows and processes, including ways of working and guardrails are sort of the next piece of the puzzle here. Going from everyone doing their own thing to teams and companies doing things together is going to be a bit of a journey.
Seems to be helping people share things around the org.
Who knows, maybe that’s a good thing.
It seems that many of these projects are not benchmarked, so it's difficult to know whether there is an improvement in any circumstance, and what the cost is. Of course, a benchmark will be fuzzy, because codebases are all different, but it'd be a start.
Many of these skills, rules, "playbooks", and such are kitchensink attempts at steering the model. It augments the model to frame it's reasoning according to project rules and flows, but cannot be really trusted to adhere to it. More of a vibe guideline.
Got rid of superpowers and other useless skills
Your LLM is more than capable of learning from the sea of knowledge
First off I would expect a (team) methodology to be referenced. There are tons to choose from. From that point on other terms may make more sense.
For example:
“ Pillar 2: Product Strategy & Architectural Governance (PDRs & ADRs)
Factor III — Mission Definition. Factor IV — Structured Planning. Factor IX — Traceability.”
Why are the Roman numerals in that order, what do they reference and why. Why is this Pilar 2. Etc. It’s easy to get lost in this, even if it would be the best approach in the world.
I dont want to be biased but i can get myself to read this after an opening like that .
For a central skills repository I would also record the exact rules revision in each run or generated artifact. Otherwise a failed run becomes hard to reproduce after the shared repository changes. It would be useful if each skill declared which claims are advisory and which are backed by a command the agent can execute and verify.
While that fork got us started, maintaining a custom fork of a CLI just to ship prompt workflows created constant merge debt and maintenance headaches. Every session, agents would still drift or forget our architecture decisions, and prompt shortcuts alone couldn't enforce team-wide standards across different developer tools.
To eliminate the fork entirely, we decoupled our workflow skills into adlc-team-skills, built on the open Agent Skills standard (SKILL.md). You install them into any repo with npx skills add tikalk/adlc-team-skills.
The setup works across a few core layers:
On session start, team-boot auto-loads your team constitution from Git and dynamically fetches only the rules, PDRs, and ADRs relevant to the active task — zero prompt-wall bloat.
For product and architecture strategy, product decisions are captured as Product Decision Records (PDRs) and compiled into PRD.md, while architectural decisions use Rozanski and Woods viewpoints composed into AD.md.
For execution, mission-brief acts as an autonomous pipeline runner that derives a formal contract (Goal, Constraints, Non-Goals, Success Criteria) and walks a specify-plan-implement-converge loop. When an agent fails, you edit the spec, not just the code.
In v0.15.0, mission-brief auto-discovers installed skills at runtime. Whether you have spec-kit, OpenSpec, Matt Pocock's skills, Addy Osmani's checklists, or custom skills installed side-by-side, the LLM dynamically decides which skill fits each pipeline step — letting us run upstream spec-kit directly with zero custom fork code.
What doesn't work well yet: our evals suite holdout-split validation is still manual. The architecture skills work, but multi-view DAG orchestration can be slow on very large codebases.
Repos: - Skills: https://github.com/tikalk/adlc-team-skills - Methodology: https://github.com/tikalk/agentic-sdlc-12-factors - CLI: https://github.com/tikalk/adlc-skills-cli
I'm curious — for those of you managing AI coding agents across engineering teams, how are you balancing team standards with the maintenance overhead of custom agent tooling?