A coding agent can read a repository, track files, edit several pieces and run tools. That capacity changes how far ** changes can be propose * but doesn’t turn every proposal into a right solution. The critical point appears when an agent gets permission to modify the same environment that an engineer uses to work, run tests or publish code.
The thesis here isn’t that delegate more better: agent engineering works as an auditory change system with context, permissions and acceptance criteria defined before performing tools. The important result isn’t a convincing response to the model but a limited diff that can be understood, tested and accepted or ruled out.
The title refers to * Jcode * but this article doesn’t describe as an actual personal flow that has been undocumented. The research dossier identifies two independent tools with that name; the following work strategy is an engineering proposal applicable to both, not a transcription of a private configuration, nor a performance test performed.
First: identify which Jcode is running the code
The ambiguity isn’t cosmetic:
| Project | Republished identity | Relevant difference |
|---|---|---|
| 1jehuang/jcode | jcode.sh | Harness written at Rust with sessions, providers, MCP, multiagent options and documented SDK |
| cnjack/jcode | j-code.net | Agent with TUI / web / desktop interfaces and approval / access modes described in your documentation |
They’re not versions of the same program. Your configuration routes, permission controls, operating models and releases are different. At the time of the source contrast, the 1jehuang/jcode repository published v0.99.1 and cnjack/jcode published v0.13.11 and these numbers identify releases, no the version used by the complainant of this blog.
An honest personal experience requires to confirm the binary, source, version, providers, permissions, tools enabled, how to isolate changes and actual review steps. Until we have that evidence, it’s not up to say “my configuration does X,” to display an invented preferences file and to assign results to the use of Harness.
The performance model matters more than the prompt
From system engineering, an agent loop combines inputs (goal, context, files and messages), a model that selects actions and a set of tools capable of reading or altering status. There are two different areas that should not be confused: the quality of the proposal and the enforcement authority.
A text response can suggest an incorrect change and a tool with shell and write access can materialise. That’s why every step of the cycle should answer a question:
- Specification. What concrete problem should be lost and how can we check?
- Context. What archives, conventions and restrictions does the agent need to know?
- Plan. What hypotheses and minimum changes do you propose before writing?
- Implementation. What directory can you conduct and what operations are allowed?
- Evidence. What actual evidence was run and with what result?
- Review. What conduct will the engineer check before integrating?
The model can complete internal steps but the computer should preserve observable evidence: affected files, diff, test command, result and decisions that require approval. The documentación de Jcode is a reference to understand the Harness 1jehuang, not a substitute for that traceability.
Specify a task that permits rejection
“Upgrading code” does not identify a verifiable output. Consider a service with an API to return a controlled error after an invalid entry. An engineering assignment can be drafted as follows:
Objetivo:
Para una petición inválida en POST /items, devolver HTTP 400 con
la estructura de error documentada, sin modificar casos exitosos.
Alcance:
Revisar el endpoint, el validador y sus pruebas.
No alterar contratos públicos distintos de este error.
Evidencia esperada:
1) Prueba que reproduzca el fallo inicial.
2) Cambio mínimo de implementación.
3) Resultado real del test de regresión y del conjunto relevante.
4) Lista de riesgos restantes.
Restricciones:
No cambiar dependencias, variables de entorno ni infraestructura.
No publicar cambios ni acceder a credenciales.
Consultar antes de modificar archivos fuera del alcance.
That text is an editorial example and an order sent to Jcode and an advanced evidence. What’s important is that it allows you to reject a solution that changes too many files, ignores the negative case or doesn’t show an observable improvement. A agent should also be able to answer that you have to reproduce the problem before editing.
Project-specific instructions, such as AGENTS.md, can help centralize conventions but their existence does not make the whole repository content reliable. That nuance becomes critical with issues, generated files, comments or third party-controlled websites.
Separate the area of change from the run area
A git worktree allows a task to have its own directory and branch without interrupting the main checkout. It doesn’t create a sandbox but reduces accidental interference with files and makes it easier to compare diff.
Example for an existing Git repository with the branch to create still free:
git status --short
git worktree list
git worktree add -b agent/validacion ../agent-validacion HEAD
The agent would only get the ../agent-validacion directory, a range of files and tools controls defined outside the prompt. Then from a review session:
git -C ../agent-validacion status --short
git -C ../agent-validacion diff --stat
git -C ../agent-validacion diff --check
git -C ../agent-validacion diff
These commands ** inspect * work, do not accept and prove its conduct. If the agent has already created commitments, we also have to inspect the range of commitments with git log and a diff against the registered base. The documentación de worktrees explain how directories and indexes coexist and this paper about workflows Git will deepen these states once published.
Security limitation is crucial: a worktree separates work files, and they do not leave the process. If an agent can run shell with the user’s identity, access SSH keys, sensitive variables or network connections, Git separation does not neutralise these permits. The SDK de jcode.sh explicitly warns that its instance isolation does not amount to a safety sandbox and recommends a container or VM for unreliable performance.
Permises: approve capabilities, not just responses
The attack surface increases as an agent can operate beyond a code directory. Read files, run local commands, connect to services and publish changes are different risk capabilities. In a reportable flow, policies have to be put into place from the tool, environment or performance system and a sentence in the prompt cannot replace effective access controls.
A progression of privileges could be:
- Reading and diagnosis: code monitoring and enforcement of permitted checks with visibility about accessible archives.
- Controlled issue: changes to a delimited worktree without touching credentials or sensitive configuration.
- Toolplay: commands under minimum permits and with appropriate isolation when code is unknown.
- External operations: explicit review before opening PRs, amending CI, accessing services or writing on a remote.
Not every tool supports the same granularity. The existence of a “plan mode” or an approval dialogue at another Jcode variant does not prove that the used binary imposes that policy. Effective documentation and controls of the individual version have to be revised. The work of NIST sobre identidad y autoridad de agentes de software emphasizes that identity, authorization and audit are different and active problems.
Prompt injection enters by data that looks like documentation
An agent reading repositories and outside pages can find text that describes code and text that aims to give instructions to agent. Those categories should not have the same authority. an issue, an alien README, a log or a tool response may include orders that contradict the user’s command.
OWASP describes prompt indirect injection as a way to manipulate system performance by means of external content. The danger does not require that the file be enforceable: its contents simply reach the model and its interpretation as a privileged instruction.
A strong policy difference origin of the instruction and content analysed. Repositories, search results and logs provide evidence to decide changes and cannot by themselves elevate the agent’s permission. When detecting a suspicious request, it’s useful to identify its provenance, omit its imperative character and continue with authorized specification.
The actual defence combines isolation, tools restrictions, separation of secrets, command review and human monitoring. The text of a prompt itself cannot guarantee that these measures exist.
The review starts before the agent says “finished”
A agent can produce tests and then say they pass. That’s only valid if the tests ** have been run * and their departures have been registered. He can also modify his own test to cover up a bug. That’s why monitoring should examine both conduct and the modification of the evaluation mechanism.
The appropriate sequence for a bugfix would be:
- Reproducing the problem with a defined test or stage.
- Record a base status and file limits allowed.
- Apply the minimum patch in an isolated context.
- Review the complete diff, including changes to tests and lockfiles.
- To run the actual Repository Test command, not an assumed one.
- Check that the regression test will fail without the fix as feasible.
- To integrate only after human acceptance.
For instance, in an Astro / Bun project that declares bun run test in his package.json, that command would be an actual candidate, and in a Rust project no. The agent should first inspect the available script **. If you cannot run it, your report should say “unrun,” and have no synthetic result. The review also requires quality signals: type errors, API changes, migrations, licenses and archives that have been put out of range.
3 and their contracts
Refactor tipped. Maintain public API and tests, limit modules and analyze diff size. The risk here is a “cleanup” that changes conduct that isn’t covered by evidence.
bug correction. require initial reproduction, explicit hypothesis, regressive and final verification. The risk here is to correct symptoms while the cause remains.
Research and PR proposal. First find sources, then compare alternatives and finally produce replaceable changes. The risk here is to transform analysis assumptions into unverified architecture events.
These patterns do not prove that the same agent will be suitable for all cases. The useful autonomy depends on Repository sensitivity, reversibility, available tools and ability to review the result.
How to measure if the delegation helps?
A issue-resolution benchmark measures a defined capacity in a controlled environment and is not a direct measure of human productivity or operational security. SWE-bench Verified brings together a human revised set and allows to evaluate agents in repair tasks but its results also depend on Harness, Resources and Evaluation Rules.
Comparison with human work requires another methodology. At an experienced ensayo aleatorizado de METR publicado en julio de 2025, open source developers have been on average about 19% more time using some earlier 2025 IA tools for the studied tasks. That result did not prove that all subsequent agents slowed down any project and did prevent them from taking acceleration as a universal assumption.
A dedicated set of comparable tasks and measurements should be recorded to evaluate an own workflow:
| Metrica | What’s his answer? | Caution |
|---|---|---|
| Time up to Reportable PR | How long does it take to have an evaluable proposal? | Include review and rework, not just generation |
| Human iterations | How many corrections does the result require? | Depends on difficulty and dune definition |
| Failed tests / regressions | What defects appear before integrating? | Differing nonexistent green evidence |
| Cost and call tools | What’s the delegation’s operational costs? | Record model, version, context and policy |
| Abandoned tasks | When isn’t it profitable to continue? | Do not hide failed sample cases |
Without a monitoring design, talking about “X times faster” is advertising, not engineering. No comparative tasks have been performed for the blog and no recursations have been measured or counted. Any figure of its own will require experiments and evidence that the complainant can support.
From proposal to acceptance
The most important technical border isn’t between handwriting or using Jcode. It’s between propose * and * accept a change. An agent can reduce friction in exploration, production of tests or repetitive changes, and the responsibility for defining contracts, evaluating security and deciding what goes into the repository remains with the equipment.
The following editorial iteration of this article can embody the complainant’s personal configuration once Jcode’s exact repository, his version, model / provider, permits, actual use of worktrees and review controls have been identified. Until then, the reported flow is deliberately a verifiable pattern propose, not a first-hand story.
That’s the justifiable standard for any assisted engineering: to specify a problem, to limit capabilities, to inspect diff, to run true tests and to preserve the possibility of rejecting the result. The agent’s a participant in that process, never his unique source of truth.