How to Effectively Solve 100+ Tasks with Claude Code

Now that we have coding agents that are extremely proficient at writing code, I experience a lot of smaller tasks coming up that have to be fixed. This is a general observation I've made from working with startups and applications: because the effort to write code has gone down so much, the threshold for providing product feedback has lowered, and requests for quick fixes have vastly increased. Of course, when doing this, you can spin up one Claude Code or Codex session per task.

However, you start having problems once you receive 50 to 100 tasks per day, where you obviously don't want to spin up that many separate coding sessions. At the same time, you don't necessarily want to put everything in one session, since you can run into context-length limits and the model may struggle to orchestrate all the tasks effectively. This is an issue I started experiencing myself a lot, and I just started developing a philosophy and methodology to solve hundreds of smaller tasks in an effective manner.

In this article, I'll take you through the methodology that I use on a daily basis to work more effectively with my Claude Code sessions to solve a lot of coding tasks. This infographic highlights the main contents of this article and discusses how to effectively solve a large number of smaller coding tasks using coding agents such as Claude Code or Open AI Codex, Image by Chat GPT. Why optimize how to solve smaller tasks As always, I'll take you through why you should care about optimizing how to solve smaller tasks.

You might think that coding agents have become so efficient that simple quick fixes are something you can just throw at a coding agent and it immediately solves everything for you, and you don't really have to think about it. To some extent, this is true. I mean, you can, in many cases, just fire off tasks, for example, a Linear task to a coding agent, and it will, in many cases, be able to solve it itself and drive it to dev and production with very little human interaction.

However, the problem arises when you start having a lot of these smaller tasks coming in, which can happen because of: Bugs Smaller feature requests Design updates and many other cases. Thus, you need a strong methodology for working through all of these tasks, verifying they're solved in a correct manner, and marking them done. Some smaller tasks can be done fully autonomously by coding agents.

However, I also found that a lot of similar-looking tasks are a bit ambiguous. If you simply ask a coding agent to fix such a task without any more input, you might find that the coding agent did not actually solve the problem, or in many cases, even worse, that the coding agent did something it wasn't supposed to do and changed a part of your application that you didn't intend to change. Due to the challenges I mentioned here: Solving a lot of smaller tasks Ambiguities in smaller tasks You need a good methodology for completing all these tasks, which is what I'll cover in the following sections.

My coding methodology Now I'll cover my coding methodology to more effectively solve a lot of these tasks. I'll take you through my high-level pipeline and the philosophy and mindset that I have for solving these tasks. The pipeline looks as follows: The issue is posted, typically through Slack An agent picks up the task and creates a Linear issue for it I have a Claude Code session to deal with all of these tasks, typically for a specific time period, for one specific day in my case.

I triage the tasks through my Claude Code session. If it's a simple quick fix, I use the Claude Code session to fix it. If it's a bigger issue, I have the agent in the session create a hand-off up front and work on a completely separate thread to solve the issue because it needs more human interaction.

I make Claude Code create an HTML report of all the smaller issues that we want to work through. If it has any questions for me, I need to clarify them and give it guidelines on how to complete t...

الآن لدينا وكلاء كتابة أكواد 능숙ين، أنا أعاني من العديد من المهام الصغيرة التي يجب إصلاحها. هذا ملاحظة عامة قمت بها من العمل مع startups والتطبيقات: لأن جهد كتابة الأكواد انخفض بشكل كبير، أصبح الحد الأدنى لتوفير ملاحظات المنتج أقل، وأصبحت طلبات الإصلاح السريع قد زادت بشكل كبير.当然，当这样做时，可以启动一个 Claude Code 或 Codex セッション لكل任务。 しかし、一度に50から100タスクを受け取ると、明らかにそれほど多くの独立のコーディングセッションを開始したくない。同時に、すべてを一つのセッションに入れたくないかもしれません、なぜならコンテキストの長さの制限にぶつかる可能性があり、モデルがすべてのタスクを効果的に調整するのに苦労するからです。これが私が頻繁に経験した問題であり、ただただ数百の小さなタスクを効果的に解決するための哲学と方法论を開発し始めたのです。この記事では、私が毎日Claude Codeセッションと効果的に作業して多くのコーディングタスクを解決するための方法論を通じてあなたを案内します。このインフォグラフィックはこの記事の主要な内容を強調し、Claude CodeやOpen AI Codexなどのコーディングエージェントを使用して多数の小さなコーディングタスクを効果的に解決する方法について議論します. لماذا تحسين طريقة حل المهام الصغيرة كما هو الحال دائماً، سأأخذك عبر لماذا يجب أن تهتم بتحسين طريقة حل المهام الصغيرة. قد تعتقد أن وكلاء كتابة الأكواد أصبحت इतनी كفؤة أن الإصلاحات البسيطة السريعة هي شيء يمكنك رميها على وكيل كتابة الأكواد ويحل كل شيء فوراً بالنسبة لك، ولا حقاً لا تحتاج للتفكير فيه. إلى حد ما، هذا صحيح. أعني، في العديد من الحالات، على سبيل المثال، يمكنك إرسال مهمة Linear إلى وكيل كتابة الأكواد، وفي العديد من الحالات سيكون قادراً على حلها بنفسه وتوجيهها إلى dev والإنتاج بتفاعل بشري قليل جداً. tuttavia, المشكلة تنشأ عندما تبدأ في الحصول على العديد من هذه المهام الصغيرة الواردة، والتي يمكن أن تحدث لأنها من: Bugs طلبات ميزات أصغر تحديثات التصميم وغيرها من الحالات. لذا، أنت بحاجة إلى منهجية قوية للعمل من خلال جميع هذه المهام، والتحقق من أنها تم حلها بشكل صحيح، وتحديدها كمكتملة. بعض المهام الصغيرة يمكن أن تكتمل بالكامل من قبل وكلاء كتابة الأكواد. tuttavia, لقد وجدت أن العديد من المهام التي تبدو مشابهة somewhat غامضة. إذا قمت ببساطة بسؤال وكيل كتابة الأكواد لإصلاح مثل هذه المهمة دون أي مدخلات إضافية، فقد تجد أن وكيل كتابة الأكواد لم actually résoudre le problème، أو في العديد من الحالات، أسوأ من ذلك، أن وكيل كتابة الأكواد فعل qualcosa لم يكن supposed à faire et غيّر جزءاً من تطبيقك أنك لم تنوِ تغييره. debido a los desafíos que mencioné aquí: حل العديد من المهام الصغيرة ambiguïtés dans les tâches petites تحتاج إلى منهجية جيدة لإنجاز جميع هذه المهام، وهذا ما سأغطيه في الأقسام التالية. منهجيتي في البرمجة الآن سأغطي منهجيتي في البرمجة لحل هذه المهام العديدة بفعالية. سأأخذك عبر pipeline عالي المستوى وفلسفتي وعقليتي لحل هذه المهام. يبدو pipeline كالتالي: المشكلة منشورة، Typically من خلال Slack وكيل يلتقط المهمة ويخلق مشكلة Linear أنا لدي جلسة Claude Code للتعامل مع جميع هذه المهام، Typically لفترة زمنية، في حالي، يومًا محددًا. أقوم بتصنيف المهام من خلال جلسة Claude Code. إذا كان سريع الإصلاح، أستخدم جلسة Claude Code لإصلاحه. إذا كان مشكلة أكبر، فلدي الوكيل في الجلسة إنشاء مقدمة handoff والعمل في خيط completely منفصل لحل المشكلة لأنها تحتاج إلى مزيد من التفاعل البشري. أجعل Claude Code ينشئ تقرير HTML لجميع المهام الصغيرة التي نريد العمل عليها. إذا كان لديه أي أسئلة بالنسبة لي، أحتاج إلى توضيحها وإعطاؤه توجيهات حول كيفية الانتهاء...

এখন আমাদের पास এমন কোডিং এজেন্টস আছে যা কোড লিখতে খুব দক্ষ। আমি অনেক ছোট কাজ পায় যা ঠিক করতে হয়। এটি আমার স্টার্টআপস এবং অ্যাপ্লিকেশনস সাথে কাজ করার থেকে একটি সাধারণ পর্যবেক্ষণ: কারণ কোড লিখার খরচ অনেক হয়ে কমেছে, তাই পণ্য ফিডব্যাক দিতে সীমা কম হয়েছে, এবং দ্রুত ফিক্সের অনুরোধ অনেক বেড়েছে।もちろん、当这样做时，可以启动一个 Claude Code 或 Codex セッション لكل任务。 しかし、一度に50から100タスクを受け取ると、明らかにそれほど多くの独立のコーディングセッションを開始したくない。同時に、すべてを一つのセッションに入れたくないかもしれません、なぜならコンテキストの長さの制限にぶつかる可能性があり、モデルがすべてのタスクを効果ively调整するのに苦労するからです।これが私が頻繁に経験した問題であり、ただただ数百の小さなタスクを効果적으로解決するための哲学と方法论を開発し始めたのです。この記事では、私が毎日Claude Codeセッションと効果的に作業して多くのコーディングタスクを解決するための方法论を通じてあなたを案内します。このインフォグラフィックはこの記事の主要な内容を強調し、Claude CodeやOpen AI Codexなどのコーディングエージェントを使用して多数の小さなコーディングタスクを効果적으로解决する方法について議论します।为什么优化解决较小任务的方法 正如我一贯所做的，我将带你了解为什么你应该关注优化解决较小任务的方法。你可能会认为，编码代理已经变得如此高效，以至于简单的快速修复是你可以直接扔给编码代理，它立即就能为你解决一切，而你不必为此费心。某种程度上，这是真的。我的意思是，在许多情况下，你可以，例如，把一个 Linear 任务发给编码代理，它在许多情况下能够自行解决它，并驱动它到 dev 和生产环境。然而，问题出现于你开始大量接收这些较小任务时，这可能会因为以下原因发生：Bugs 较小的功能请求 设计更新以及许多其他情况。因此，你需要一个强大的方法论来完成所有这些任务，验证它们是否正确解决，并将它们标记为完成。一些较小的任务可以由编码代理完全自主完成。然而，我我也发现许多看起来相似的任务有点模棱两可。如果你仅仅让编码代理在没有任何额外输入的情况下修复这样的任务，你可能会发现编码代理并没有实际解决问题，或者更糟糕的是，编码代理做了它本不该做的事情，并改变了你应用程序的一部分，而你并不想改变。由于我提到的这些挑战：解决大量较小任务 较小任务的模棱两可 你需要一个好的方法论来完成所有这些任务，这就是我将在以下章节中涵盖的内容。我的编码方法论 现在我将介绍我的编码方法论，以更有效地解决大量这些任务。我将带你了解我的高级流程以及我解决这些任务的哲学和心态。流程如下： 问题通常通过 Slack 发布 一个代理为其创建一个 Linear 问题 我有一个 Claude Code 会话来处理所有这些任务，通常针对特定的时间段，对我而言，是一天中的特定时间。我通过我的 Claude Code 会话对任务进行分类。如果是一个简单的快速修复，我使用 Claude Code 会话来修复它。如果是一个更大的问题，我让会话中的代理提前进行转交，并单独在一条线程上解决问题，因为它需要更多的人工互动。我让 Claude Code 创建所有我们想要处理的较小问题的 HTML 报告。如果它对我有任何问题，我需要澄清它们并给出完成...

Jetzt haben wir Coding-Agenten, die extrem proficient am Schreiben von Code sind. Ich erlebe viele kleinere Aufgaben, die erledigt werden müssen. Dies ist eine allgemeine Beobachtung, die ich von der Arbeit mit Startups und Anwendungen gemacht habe: weil der Aufwand für das Schreiben von Code so stark gesunken ist, ist die Schwelle für die Produktfeedback-Eingabe gesunken, und Anfragen für schnelle Korrektionen sind stark gestiegen.

Natürlich kann man bei dieser Aufgabe eine Claude Code oder Codex Session pro Aufgabe starten. Allerdings beginnt man Probleme zu haben, sobald man 50 bis 100 Aufgaben pro Tag erhält, von denen man offensichtlich nicht möchte, so viele separate Coding-Sessions zu starten. Gleichzeitig möchte man nicht unbedingt alles in einer Session haben, da man sonst in Kontextlängenlimits geraten kann und das Modell möglicherweise nicht in der Lage ist, alle Aufgaben effektiv zu orchestrieren.

Das ist ein Problem, das ich oft erlebt habe, und ich habe gerade eine Philosophie und Methodik entwickelt, um hunderte kleiner Aufgaben effektiv zu lösen. In diesem Artikel führe ich dich durch die Methodik, die ich täglich anwende, um effektiver mit meinen Claude Code-Sessions zu arbeiten und viele Coding-Aufgaben zu lösen. Dieser Infografik hebt die Hauptinhalte dieses Artikels hervor und diskutiert, wie man mit Coding-Agenten wie Claude Code oder Open AI Codex effektiv viele kleinere Coding-Aufgaben lösen kann.

Warum Optimierung der Lösung kleinerer Aufgaben Wie immer führe ich dich durch die Gründe, warum du dich um die Optimierung der Lösung kleinerer Aufgaben kümmern solltest. Du könntest denken, dass Coding-Agenten so effizient geworden sind, dass einfache Quick-Fixes etwas sind, das du einem Coding-Agenten werfen kannst und er löst alles sofort für dich, und du musst dir darüber keine Gedanken machen. In gewissem Maße ist das wahr.

Ich meine, in vielen Fällen kannst du beispielsweise eine Linear-Aufgabe an einen Coding-Agenten werfen, und in vielen Fällen ist er in der Lage, sie selbst zu lösen und sie dev und Produktion mit sehr wenig menschlicher Interaktion zu steuern. Allerdings tritt das Problem auf, wenn du beginnst, 50 bis 100 Aufgaben pro Tag zu erhalten, von denen du offensichtlich nicht möchtest, so viele separate Coding-Sessions zu starten. Gleichzeitig möchtest du nicht unbedingt alles in einer Session haben, da du sonst in Kontextlängenlimits geraten kannst und das Modell möglicherweise nicht in der Lage ist, alle Aufgaben effektiv zu orchestrieren.

Das ist ein Problem, das ich oft erlebt habe, und ich habe gerade eine Philosophie und Methodik entwickelt, um hunderte kleiner Aufgaben effektiv zu lösen. In diesem Artikel führe ich dich durch die Methodik, die ich täglich anwende, um effektiver mit meinen Claude Code-Sessions zu arbeiten und viele Coding-Aufgaben zu lösen. Dieser Infografik hebt die Hauptinhalte dieses Artikels hervor und diskutiert, wie man mit Coding-Agenten wie Claude Code oder Open AI Codex effektiv viele kleinere Coding-Aufgaben lösen kann.

Ahora tenemos agentes de codificación extremadamente proficientes escribiendo código. Experimento muchas tareas pequeñas que deben arreglarse. Es una observación general que he hecho trabajando con startups y aplicaciones: porque el esfuerzo para escribir código ha disminuido tanto, el umbral para proporcionar retroalimentación de producto ha bajado, y las solicitudes de correcciones rápidas han aumentado enormemente.

Por supuesto, cuando hacemos esto, podemos iniciar una sesión de Claude Code o Codex por tarea. Sin embargo, una vez que recibo de 50 a 100 tareas al día, obviamente no quiero iniciar tantas sesiones de código separadas. Al mismo tiempo, no necesariamente quiero poner todo en una sola sesión, ya que puedo encontrar límites de longitud de contexto y el modelo puede tener dificultades para orquestar todas las tareas de manera efectiva.

Este es un problema con el que empecé a experimentar mucho, y acabo de empezar a desarrollar una filosofía y metodología para resolver cientos de tareas pequeñas de manera efectiva. En este artículo, te llevaré a través de la metodología que uso a diario para trabajar de manera más eficaz con mis sesiones de Claude Code para resolver muchas tareas de codificación. Este infográfico resalta los contenidos principales de este artículo y discute cómo resolver eficazmente un gran número de tareas de codificación más pequeñas usando agentes de codificación como Claude Code o Open AI Codex.

Por qué optimizar cómo resolver tareas más pequeñas Como siempre, te llevaré a través de por qué deberías preocuparte por optimizar cómo resolver tareas más pequeñas. Podrías pensar que los agentes de codificación se han vuelto tan eficientes que los simples correcciones rápidas son algo que puedes lanzar a un agente de codificación y este inmediatamente resuelve todo por ti, y realmente no tienes que pensar en ello. En cierto modo, esto es cierto.

Quiero decir, en muchos casos, puedes, por ejemplo, enviar una tarea de Linear a un agente de codificación, y en muchos casos será capaz de resolverlo mismo y llevarlo a dev y producción con muy poco interacción humana. Sin embargo, el problema surge cuando empiezas a tener muchas de estas tareas más pequeñas entrantes, lo cual puede suceder porque de: Bugs Solicitudes de funciones más pequeñas Actualizaciones de diseño y muchos otros casos. Así que necesitas una metodología sólida para trabajar a través de todas estas tareas, verificando que se resuelven de manera correcta y marcándolas como completadas.

Algunas tareas más pequeñas pueden ser completamente autónomas por agentes de codificación. Sin embargo, también encontré que muchas tareas que se parecen no son ambiguas. Si simplemente le pides a un agente de codificación que arregle tal tarea sin más entrada, es posible que descubras que el agente de codificación realmente no resolvió el problema, o en muchos casos, peor aún, que el agente de codificación hizo algo que no estaba supuesto a hacer y cambió una parte de tu aplicación que no intended cambiar.

Debido a los desafíos que mencioné aquí: Resolviendo muchas tareas más pequeñas Ambigüedades en tareas más pequeñas Necesitas una buena metodología para completar todas estas tareas, que es lo que cubriré en las secciones siguientes. Mi metodología de codificación Ahora cubriré mi metodología de codificación para resolver de manera más eficaz muchas de estas tareas. Te llevaré a través de mi pipeline de alto nivel y la filosofía y mentalidad que tengo para resolver estas tareas.

El pipeline se ve así: El problema se publica, típicamente a través de Slack Un agente recoge la tarea y crea un problema de Linear Yo tengo una sesión de Claude Code para lidiar con todas estas tareas, típicamente por un período de tiempo, en mi caso, un día específico. Triage las tareas a través de mi sesión de Claude Code. Si es un rápido arreglo, uso la sesión de Claude Code para arreglarlo.

Si es un problema mayor, tengo al agente en la sesión crear un frente de antemano y trabajar en un hilo completamente separado para resolver el problema porque necesita más interacción humana. Hago que Claude Code cree un informe HTML de todas las tareas más pequeñas que queramos trabajar. Si tiene alguna pregunta para mí, necesito aclararlas y darles directrices sobre cómo complet...

Maintenant, nous avons des agents de codage extrêmement habiles à écrire du code. Je suis confronté à de nombreuses petites tâches à résoudre. C'est une observation générale que j'ai faite en travaillant avec des startups et des applications : puisque l'effort d'écriture de code a beaucoup diminué, le seuil pour fournir des commentaires sur le produit a baissé, et les demandes de correctifs rapides ont considérablement augmenté.

Bien sûr, quand on fait cela, on peut lancer une session Claude Code ou Codex par tâche. Cependant, une fois que l'on reçoit de 50 à 100 tâches par jour, on évidemment ne veut pas lancer autant de sessions de code séparées. En même temps, on ne veut pas forcément tout mettre dans une seule session, car on peut rencontrer des limites de longueur de contexte et le modèle peut avoir du mal à orchestrer efficacement toutes les tâches.

C'est un problème que j'ai commencé à vivre beaucoup, et je viens tout juste de développer une philosophie et une méthodologie pour résoudre efficacement des centaines de petites tâches. Dans cet article, je te guiderai à travers la méthodologie que j'utilise quotidiennement pour travailler plus efficacement avec mes sessions Claude Code afin de résoudre un grand nombre de tâches de codage. Cet infographie met en évidence les contenus principaux de cet article et discute comment résoudre efficacement un grand nombre de petites tâches de codage en utilisant des agents de codage tels que Claude Code ou Open AI Codex.

Pourquoi optimiser la façon de résoudre les tâches plus petites Comme toujours, je te guiderai à travers pourquoi tu devrais te soucier d'optimiser la façon de résoudre les tâches plus petites. Tu pourrais penser que les agents de codage sont devenus si efficaces que les simples correctifs rapides sont quelque chose que tu peux lancer à un agent de codage et qu'il résout immédiatement tout pour toi, et tu n'as vraiment pas à y penser. Dans une certaine mesure, c'est vrai.

Je veux dire, dans de nombreux cas, tu peux, par exemple, envoyer une tâche Linear à un agent de codage, et dans de nombreux cas, il sera capable de la résoudre lui-même et de la conduire à dev et production avec très peu d'interaction humaine. Cependant, le problème survient quand tu commences à recevoir beaucoup plus de ces petites tâches, ce qui peut arriver parce que : Bugs Petites demandes de fonctionnalités Mises à jour de conception et bien d'autres cas. Ainsi, tu as besoin d'une bonne méthodologie pour travailler à travers toutes ces tâches, en vérifiant qu'elles sont résolues de manière correcte, et en les marquant comme terminées.

Certaines petites tâches peuvent être entièrement autonomes par des agents de codage. Cependant, j'ai aussi trouvé que beaucoup de tâches qui ressemblent un peu ambiguës. Si tu demandes simplement à un agent de codage de fixer une telle tâche sans aucune entrée supplémentaire, tu pourrais trouver que l'agent de codage n'a pas résolu le problème, ou dans bien des cas, pire encore, que l'agent de codage a fait quelque chose qu'il n'était pas supposé faire et a changé une partie de ton application que tu n'avais pas l'intention de changer.

En raison des défis que j'ai mentionnés ici : Résoudre beaucoup de petites tâches Ambiguïtés dans les petites tâches Tu as besoin d'une bonne méthodologie pour terminer toutes ces tâches, c'est ce que je couvrirai dans les sections suivantes. Ma méthodologie de codification Maintenant, je te couvrirai ma méthodologie de codification pour résoudre plus efficacement beaucoup de ces tâches. Je te guiderai à travers mon pipeline de haut niveau et la philosophie et l'état d'esprit que j'ai pour résoudre ces tâches.

Le pipeline semble ainsi : Le problème est publié, typiquement via Slack Un agent récupère la tâche et crée un problème Linear J'ai une session Claude Code pour gérer toutes ces tâches, typiquement pour une période de temps, dans mon cas, un jour spécifique. Je triage les tâches à travers ma session Claude Code. Si c'est un rapide correctif, j'utilise la session Claude Code pour le fixer.

Si c'est un problème plus important, j'ai l'agent dans la session créer un handoff à l'avance et travailler sur un fil complètement séparé pour résoudre le problème car il nécessite plus d'interaction humaine. Je fais créer à Claude Code un rapport HTML de toutes les petites tâches que nous voulons travailler. Si elle a des questions pour moi, je dois les clarifier et lui donner des directives sur la façon de terminer...

अब हमारे पास ऐसे कोडिंग एजेंट्स हैं जो कोड लिखने में अत्यधिक कुशल हैं। मुझे छोटे-छोटे कार्यों के बहुत सारे आने का अनुभव हो रहा है जिन्हें ठीक करने की जरूरत है। यह एक सामान्य अवलोकन है जिसे मैं स्टार्टअप्स और एप्लिकेशन के साथ काम करते हुए बनाया है: क्योंकि कोड लिखने का प्रयास काफी कम हो गया है, उत्पाद प्रतिक्रिया देने की सीमा कम हो गई है, और त्वरित सुधारों के लिएrequests काफी बढ़ गए हैं। बेशक, जब हम ऐसा करते हैं, तो हम एक Claude Code या Codex सत्र प्रति कार्य शुरू कर सकते हैं। हालांकि, एक बार जब हमें प्रतिदिन 50 से 100 कार्य मिलते हैं, तो स्पष्ट रूप से हम इतनी अलग-अलग कोडिंग सत्र शुरू नहीं करना चाहते। साथ ही, हम हर चीज को एक सत्र में नहीं डालना चाहते, क्योंकि हमें संदर्भ लंबाई की सीमाओं का सामना करना पड़ सकता है और मॉडल सभी कार्यों को प्रभावी ढंग से समन्वयित करने में संघर्ष कर सकता है। यही समस्या मुझे काफी अनुभव हुई है, और मुझे एक दर्शन और पद्धति विकसित करने की शुरुआत हुई है ताकि सौ से अधिक छोटे कार्यों को प्रभावी ढंग से हल किया जा सके। इस लेख में, मैं आपको वह पद्धति बताऊंगा जिसे मैं रोजाना उपयोग करता हूं ताकि मेरे Claude Code सत्रों के साथ बहुत सारे कोडिंग कार्यों को प्रभावी ढंग से हल कर सकूं। यह इन्फोग्राफिक इस लेख की मुख्य सामग्री को उजागर करता है और चर्चा करता है कि Claude Code या Open AI Codex जैसे कोडिंग एजेंट्स का उपयोग करके बड़ी संख्या में छोटे कोडिंग कार्यों को कैसे हल किया जाए। क्यों छोटे कार्यों को हल करने के तरीके को अनुकूलित करें जैसा कि मैं हमेशा करता हूं, मैं आपको बताऊंगा कि आपको छोटे कार्यों को हल करने के तरीके को अनुकूलित करने पर क्यों ध्यान देना चाहिए। आपको लग सकता है कि कोडिंग एजेंट्स इतनी कुशल हो गई हैं कि सरल त्वरित सुधार उन्हेें दे दिए जाएं और यह तुरंत सब कुछ हल कर दे, और आपको इसके बारे में सोचने की आवश्यकता नहीं है। कुछ हद तक, यह सच है। मेरा मतलब है, आप कई मामलों में, उदाहरण के लिए, एक Linear कार्य को एक कोडिंग एजेंट को सौंप सकते हैं, और कई मामलों में, यह स्वयं इसे हल करने में सक्षम होगा और इसे dev और उत्पादन में ले जाएगा बहुत कम मानवीय हस्तक्षेप के साथ। हालांकि, समस्या उस समय उत्पन्न होती है जब आप बहुत सारे इन छोटे कार्यों को प्राप्त करना शुरू करते हैं, जो हो सकता है क्योंकि: Bugs छोटे सुविधा अनुरोध डिजाइन अपडेट और कई अन्य मामले। इसलिए, आपको सभी इन कार्यों को पूरा करने के लिए एक अच्छी विधि की आवश्यकता है, यह सत्यापित करते हुए कि उन्हें सही तरीके से हल किया गया है, और उन्हें पूरा चिह्नित करें। कुछ छोटे कार्यों को कोडिंग एजेंट्स द्वारा पूरी तरह से स्वायत्त रूप से किया जा सकता है। हालांकि, मुझे यह भी मिला कि बहुत सारे दिखने में समान कार थोड़े अस्पष्ट होते हैं। यदि आप बस एक कोडिंग एजेंट से बिना किसी अतिरिक्त इनपुट के such एक कार्य को ठीक करने के लिए कहते हैं, तो आप पा सकते हैं कि कोडिंग एजेंट वास्तव में समस्या को हल नहीं किया है, या बदतर मामले में, कि कोडिंग एजेंट ने ऐसा किया जिसे वह करने वाला नहीं था और आपके एप्लिकेशन के एक हिस्से को बदल दिया जिसे आप बदलना नहीं चाहते थे। मुझे उल्लिखित इन चुनौतियों के कारण: बहुत सारे छोटे कार्यों को हल करना छोटे कार्यों की अस्पष्टता आपको सभी इन कार्यों को पूरा करने के लिए एक अच्छी विधि की आवश्यकता है, जो कि मैं निम्नलिखित अनुभागों में कवर करूंगा। मेरा कोडिंग विधि अब मैं अपने कोडिंग विधि को अधिक प्रभावी ढंग से बहुत सारे इन कार्यों को हल करने के लिए कवर करूंगा। मैं आपको अपने उच्च स्तरीय पाइपलाइन और मुझे इन कार्यों को हल करने के लिए filosofy और मानसिकता के बारे में बताऊंगा। पाइपलाइन इस प्रकार दिखती है: समस्या Typically के माध्यम से Slack प्रकाशित किया गया एक एजेंट इसे उठाता है और एक Linear समस्या बनाता है मुझे एक Claude Code सत्र सभी इन कार्यों के लिए, आमतौर पर एक समय अवधि के लिए, मेरे मामले में एक विशिष्ट दिन। मुझे अपने Claude Code सत्र के माध्यम से कार्यों का वर्गीकरण करना है। यदि यह एक सरल त्वरित सुधार है, तो मुझे Claude Code सत्र का उपयोग करके इसे ठीक करना है। यदि यह एक बड़ी समस्या है, तो मुझे सत्र में एजेंट को एक अग्रिम हस्तांतरण करना है और एक पूरी तरह से अलग धागे पर समस्या को हल करना है क्योंकि यह अधिक मानवीय बातचीत की आवश्यकता है। मुझे Claude Code को सभी छोटी समस्याओं का HTML रिपोर्ट बनाना है जिसे हम काम करना चाहते हैं। यदि इसमें मुझे कोई प्रश्न है, तो मुझे उन्हें स्पष्ट करना है और उन्हें यह बताना है कि कैसे पूरा...

Sekarang kita memiliki coding agent yang sangat proficient menulis kode, saya mengalami banyak tugas kecil yang harus diperbaiki. Ini adalah observasi umum yang saya buat dari bekerja dengan startup dan aplikasi: karena usaha menulis kode telah turun drastis, ambang batas memberikan umpan balik produk telah turun, dan permintaan perbaikan cepat telah meningkat drastis. Tentu, ketika kita melakukan ini, kita bisa memulai satu sesi Claude Code atau Codex per tugas.

Namun, begitu kita menerima 50 hingga 100 tugas per hari, tentu saja kita tidak ingin memulai begitu banyak sesi coding terpisah. Pada saat yang sama, kita tidak tentu ingin memasukkan semua tugas dalam satu sesi, karena kita bisa menghadapi batas panjang konteks dan model mungkin kesulit untuk mengorkestrasi semua tugas secara efektif. Ini adalah masalah yang saya sering alami, dan baru saja mulai mengembangkan filsafat dan metodologi untuk secara efektif menyelesaikan ratusan tugas kecil.

Dalam artikel ini, saya akan membawa Anda melalui metodologi yang saya gunakan sehari-hari untuk bekerja lebih efektif dengan sesi Claude Code saya untuk menyelesaikan banyak tugas coding. Infografis ini menonjolkan konten utama artikel ini dan membahas cara secara efektif menyelesaikan banyak tugas coding kecil menggunakan coding agent seperti Claude Code atau Open AI Codex. Mengapa mengoptimalkan cara menyelesaikan tugas yang lebih kecil Seperti yang selalu saya lakukan, saya akan membawa Anda melalui mengapa Anda harus memperhatikan mengoptimalkan cara menyelesaikan tugas yang lebih kecil.

Anda mungkin berpikir bahwa coding agent sudah menjadi begitu efisien sehingga perbaikan cepat yang sederhana adalah sesuatu yang bisa Anda lempar ke coding agent dan ia segera menyelesaikannya untuk Anda, dan Anda tidak perlu memikirkan hal ini. Sebagian besar, ini benar. Artinya, dalam banyak kasus, misalnya, Anda bisa mengirim tugas Linear ke coding agent, dan dalam banyak kasus, ia mampu menyelesaikannya sendiri dan mengemudakannya ke dev dan produksi dengan sangat sedikit interaksi manusia.

Namun, masalah muncul ketika Anda mulai menerima banyak tugas kecil ini, yang bisa terjadi karena: Bugs Fitur kecil Desain pembaruan dan banyak kasus lainnya. Oleh karena itu, Anda butuh metodologi yang bagus untuk menyelesaikan semua tugas ini, memverifikasi bahwa mereka diselesaikan dengan benar, dan menandai mereka sebagai selesai. Beberapa tugas kecil bisa secara otonom oleh coding agent diselesaikan.

Namun, saya juga menemukan bahwa banyak tugas yang mirip sedikit ambigu. Jika Anda hanya meminta coding agent untuk memperbaiki tugas seperti ini tanpa input tambahan, Anda mungkin menemukan bahwa coding agent sebenarnya tidak menyelesaikan masalah, atau malah lebih buruk, coding agent melakukan sesuatu yang seharusnya tidak dilakukan dan mengubah bagian dari aplikasi Anda yang Anda tidak ingin diubah. Dampingi tantangan yang saya sebutkan di sini: Menyelesaikan banyak tugas kecil Ambiguitas pada tugas kecil Anda butuh metodologi yang bagus untuk menyelesaikan semua tugas ini, yang akan saya tutup dalam bagian-bagian selanjutnya.

Metodologi coding saya Sekarang saya akan memperkenalkan metodologi coding saya untuk lebih efektif menyelesaikan banyak tugas ini. Saya akan membawa Anda melalui pipeline tingkat tinggi dan filsafat dan mentalitas yang saya miliki untuk menyelesaikan tugas-tugas ini. Pipeline terlihat sebagai berikut: Masalah biasanya dipublikasikan melalui Slack Satu agen mengambil tugas dan membuat Linear Masalah Saya memiliki sesi Claude Code untuk menangani semua tugas ini, biasanya untuk periode waktu, untuk kasus saya, hari tertentu.

Saya triage tugas melalui sesi Claude Code. Jika itu tugas sederhana perbaikan cepat, saya menggunakan sesi Claude Code untuk memperbaikinya. Jika itu masalah yang lebih besar, saya meminta agen di sesi untuk membuat handoff terlebih dahulu dan bekerja di thread terpisah untuk menyelesaikan masalah karena butuh lebih banyak interaksi manusia.

Saya meminta Claude Code untuk membuat HTML laporan semua tugas kecil yang ingin kita kerjakan. Jika ia punya pertanyaan untuk saya, saya perlu mengklarifikasi mereka dan memberinya petunjuk bagaimana menyelesaikannya...

now we have coding agents that are extremely proficient at writing code, I experience a lot of smaller tasks coming up that have to be fixed. This is a general observation I've made from working with startups and applications: because the effort to write code has gone down so much, the threshold for providing product feedback has lowered, and requests for quick fixes have vastly increased. Of course, when doing this, you can spin up one Claude Code or Codex session per task.

However, you start having problems once you receive 50 to 100 tasks per day, where you obviously don't want to spin up that many separate coding sessions. At the same time, you don't necessarily want to put everything in one session, since you can run into context-length limits and the model may struggle to orchestrate all the tasks effectively. This is an issue I started experiencing myself a lot, and I just started developing a philosophy and methodology to solve hundreds of smaller tasks in an effective manner.

In this article, I'll take you through the methodology that I use on a daily basis to work more effectively with my Claude Code sessions to solve a lot of coding tasks. This infographic highlights the main contents of this article and discusses how to effectively solve a large number of smaller coding tasks using coding agents such as Claude Code or Open AI Codex, Image by Chat GPT.なぜ小タスクの解決方法を最適化するのか いつも通り、小タスクの解決方法を最適化する理由について説明します。コーディングエージェントがこれほど効率的になるにつれて、単なるクイックフィックスはコーディングエージェントに投げ込むだけで即座にすべてを解決してくれると思うかもしれませんし、特に考える必要はないかもしれません。ある程度は真実です。つまり、多くのケースでは、例えばLinearタスクをコーディングエージェントに送信し、多くの場合、エージェント自身がそれを解決し、非常に少ない人的介入でdevとproductionに駆動できます。しかし、問題は50から100のタスクを1日で受け取るようになったときに発生します。明らかに、それほど多くの別々のコーディングセッションを立ち上げたくはありません。同時に、1つのセッションにすべてを入れたくもありません。なぜなら、コンテキスト長の制限にぶつかる可能性があり、モデルがすべてのタスクを効果的にオーケストレーションするのに苦労するからです。これが私が頻繁に経験した問題であり、ただただ数百の小さなタスクを効果的に解決するための哲学と方法論を開発し始めたのです。この記事では、私が毎日Claude Codeセッションと効果的に作業して多くのコーディングタスクを解決するための方法論を通じてあなたを案内します。このインフォグラフィックはこの記事の主要な内容を強調し、Claude CodeやOpen AI Codexなどのコーディングエージェントを使用して多数の小さなコーディングタスクを効果的に解决する方法について議论します。.

Agora temos agentes de codificação extremamente proficientes escrevendo código. Eu experimento muitas tarefas pequenas que need to be fixed. Esta é uma observação geral que fiz trabalhando com startups e aplicativos: porque o esforço para escrever código diminuiu tanto, o limite para fornecer feedback de produto diminuiu, e solicitações de correções rápidas aumentaram drasticamente.

Obviamente, quando fazemos isso, podemos iniciar uma sessão Claude Code ou Codex por tarefa. No entanto, uma vez que recebemos de 50 a 100 tarefas por dia, obviamente não queremos iniciar tantas sessões de código separadas. Ao mesmo tempo, não necessariamente queremos colocar tudo em uma única sessão, pois podemos encontrar limites de comprimento de contexto e o modelo pode ter dificuldade em orquestrar todas as tarefas de forma eficaz.

Este é um problema com o qual comecei a experimentar muito, e acabei de começar a desenvolver uma filosofia e metodologia para resolver centenas de tarefas menores de forma eficaz. Neste artigo, levarei você através da metodologia que uso diariamente para trabalhar mais eficazmente com minhas sessões Claude Code para resolver muitas tarefas de codificação. Este infográfico destaca os conteúdos principais deste artigo e discute como resolver eficazmente um grande número de tarefas menores de codificação usando agentes de codificação como Claude Code ou Open AI Codex.

Por que otimizar como resolver tarefas menores Como sempre, levarei você através do porquê você deve se preocupar em otimizar como resolver tarefas menores. Você pode pensar que agentes de codificação se tornaram tão eficientes que correções rápidas simples são algo que você pode jogar a um agente de codificação e ele imediatamente resolve tudo para você, e você realmente não precisa pensar sobre isso. Em certa medida, isso é verdade.

Quer dizer, em muitos casos, você pode, por exemplo, enviar uma tarefa Linear a um agente de codificação, e em muitos casos será capaz de resolvê-la mesma e levá-la a dev e produção com muito pouco interação humana. No entanto, o problema surge quando você começa a receber muitas dessas tarefas menores, o que pode acontecer porque de: Bugs Solicitações de recursos menores Atualizações de design e muitos outros casos. Assim, você precisa de uma boa metodologia para trabalhar através de todas essas tarefas, verificando se elas são resolvidas de forma correta e marcando-as como concluídas.

Algumas tarefas menores podem ser totalmente autônomas por agentes de codificação. No entanto, também encontrei que muitas tarefas que se parecem um pouco ambíguas. Se você simplesmente pede a um agente de codificação que corrija tal tarefa sem nenhuma entrada adicional, você pode descobrir que o agente de codificação realmente não resolveu o problema, ou em muitos casos, pior ainda, que o agente de codificação fez algo que não estava suposto a fazer e mudou uma parte do seu aplicativo que você não pretendia mudar.

Devido aos desafios que mencionei aqui: Resolvendo muitas tarefas menores Ambiguações em tarefas menores Você precisa de uma boa metodologia para completar todas essas tarefas, que é o que cobrirei nas seções seguintes. Minha metodologia de codificação Agora cobrirei minha metodologia de codificação para resolver de maneira mais eficaz muitas dessas tarefas. Levarei você através do meu pipeline de alto nível e da filosofia e mentalidade que tenho para resolver essas tarefas.

O pipeline parece assim: O problema é publicado, tipicamente através do Slack Um agente pega a tarefa e cria um problema Linear Eu tenho uma sessão Claude Code para lidar com todas essas tarefas, tipicamente por um período de tempo, no meu caso, um dia específico. Eu faço triagem das tarefas através da minha sessão Claude Code. Se for um rápido conserto, uso a sessão Claude Code para consertá-lo.

Se for um problema maior, tenho o agente na sessão criar um handoff na frente e trabalhar em um fio completamente separado para resolver o problema porque precisa mais interação humana. Faço o Claude Code criar um relatório HTML de todas as tarefas menores que queremos trabalhar. Se ela tiver alguma pergunta para mim, preciso aclará-la e dar diretrizes sobre como complet...

Теперь у нас есть кодинг-агенты, которые очень умеют писать код. Я часто сталкиваюсь с малым количеством задач, которые нужно исправить. Это общий observation, который я сделал, работая с стартапами и приложениями: поскольку нéры efforts код писать снизилось так много, порог предоставления обратной связи по продукту снизился, и запросы быстрых исправлений значительно возросли.当然，当这样做时，可以启动一个 Claude Code 或 Codex セッション لكل任务。 しかし、一度に50から100タスクを受け取ると、明らかにそれほど多くの独立のコーディングセッションを開始したくない。同時に、すべてを一つのセッションに入れたくないかもしげません、因为コンテキストの长さの制限にぶつかる可能性があり、モデルがすべてのタスクを効果적으로调整するのに苦労するからです。これが私が頻繁に経験した问题であり、ただただ数百の小さなタスクを効果적으로解决するための哲学と方法论を開発し始めたのです。この記事では、私が毎日Claude Codeセッションと効果적으로作业して多くのコーディングタスクを解决するための方法论を通じてあなたを案内します。このインフォグラフィックはこの記事の主要な内容を强调し、Claude CodeやOpen AI Codexなどのコーディングエージェントを使用して多数の小さなコーディングタスクを効果적으로解决する方法について議论します. Почему стоит оптимизировать решение мелких задач Как всегда, я проведу вас через почему вы должны заботиться об оптимизации решения мелких задач. Может, вы думаете, что кодинг-агенты стали настолько эффективны, что простые быстрые исправления — это Thing, которое вы можете кинуть кодинг-агенту, и он сразу же решает всё для вас, и вам действительно не нужно об этом думать. В некоторой степени это правда. Я имею в виду, в многих случаях вы можете, например, отправить задачу Linear кодинг-агенту, и в многих случаях он сможет решить её сам и провести её в dev и производство с очень мало человеческого взаимодействия. Однако проблема возникает, когда вы начинаете получать много этих мелких задач, что может происходить потому что: Баги Маленькие запросы функций Обновления дизайна и многие другие случаи. Таким образом, вам нужен хороший методологию для прохождения всех этих задач, проверяя, что они решены правильно, и помечая их как завершенные. Некоторые мелкие задачи могут быть полностью автономны кодинг-агентами. Однако я также нашел, что много похожих задач немного неясны. Если вы просто попросите кодинг-агента исправить такую задачу без дополнительных входных данных, вы можете найти, что кодинг-агент на самом деле не решил проблему, или, что еще хуже, что кодинг-агент сделал то, что ему не следовало делать, и изменил часть вашего приложения, которое вы не планировали менять. Из-за упомянутых мной вызовов: Решение многих мелких задач Неясности мелких задач Вам нужен хороший методологию для завершения всех этих задач, что я покрываю в следующих разделах. Моя методология кодирования Теперь я проведу вас через мою методологию кодирования для более эффективного решения многих этих задач. Я проведу вас через мой высокий уровень pipeline и философию и ментальность, которые у меня есть для решения этих задач. Pipeline выглядит так: Проблема обычно публикуется через Slack Агент забирает задачу и создает Linear Проблема У меня есть сессия Claude Code для обработки всех этих задач, обычно для временного периода, в моем случае, конкретный день. Я триию задачи через мою сессию Claude Code. Если это простое быстрое исправление, я использую сессию Claude Code для его исправления. Если это большая проблема, у меня агент в сессии создает предварительный handoff и работает в完全 separate потоке для решения проблемы, так как ей нужна более человеческая взаимодействие. Я заставляю Claude Code создать HTML отчет всех мелких задач, которые мы хотим обработать. Если у неё есть вопросы ко мне, мне нужно уточнить их и дать ей указания, как завершить...

现在我们拥有极其擅长编写代码的编码代理，我经常遇到许多需要修复的小任务。这是我从与初创公司和应用程序合作中总结出的一个普遍观察：由于编写代码的精力大幅降低，提供产品反馈的门槛降低，快速修复的请求大幅增加。当然，当这样做时，你可以为每个任务启动一个 Claude Code 或 Codex 会话。然而，一旦你每天收到 50 到 100 个任务，你显然不想启动那么多独立的编码会话。同时，你也不一定想把所有任务都放在一个会话中，因为你可能会遇到上下文长度限制，模型可能难以有效协调所有任务。这就是我开始经常遇到的问题，我刚刚开始制定一种哲学和方法论，以有效的方式解决数百个较小的任务。在这篇文章中，我将带你了解我每天用来更有效地与 Claude Code 会话协作以解决大量编码任务的方法论。这篇文章的信息图突出了主要内容，并讨论了如何使用 Claude Code 或 Open AI Codex 等编码代理有效地解决大量较小的编码任务。为什么要优化解决较小任务的方法 正如我一贯所做的，我将带你了解为什么你应该关注优化解决较小任务的方法。你可能会认为，编码代理已经变得如此高效，以至于简单的快速修复是你可以直接扔给编码代理，它立即就能为你解决一切，而你不必为此费心。在某种程度上，这是真的。我的意思是，在许多情况下，你可以，例如，把一个 Linear 任务发给编码代理，它在许多情况下能够自行解决它，并以非常少的人工互动将其驱动到开发和生产环境。然而，问题出现于你开始大量接收这些较小任务时，这可能会因为以下原因发生：Bugs 较小的功能请求 设计更新以及许多其他情况。因此，你需要一个强大的方法论来完成所有这些任务，验证它们是否正确解决，并将它们标记为完成。一些较小的任务可以由编码代理完全自主完成。然而，我也发现许多看起来相似的任务有点模棱两可。如果你仅仅让编码代理在没有任何额外输入的情况下修复这样的任务，你可能会发现编码代理并没有实际解决问题，或者更糟糕的是，编码代理做了它本不该做的事情，并改变了你应用程序的一部分，而你并不想改变。由于我提到的这些挑战：解决大量较小任务 较小任务的模棱两可 你需要一个好的方法论来完成所有这些任务，这就是我将在以下章节中涵盖的内容。我的编码方法论 现在我将介绍我的编码方法论，以更有效地解决大量这些任务。我将带你了解我的高级流程以及我解决这些任务的哲学和心态。流程如下： 问题通常通过 Slack 发布 一个代理为其创建一个 Linear 问题 我有一个 Claude Code 会话来处理所有这些任务，通常针对特定的时间段，对我而言，是一天中的特定时间。我通过我的 Claude Code 会话对任务进行分类。如果是一个简单的快速修复，我使用 Claude Code 会话来修复它。如果是一个更大的问题，我让会话中的代理提前进行转交，并单独在一条线程上解决问题，因为它需要更多的人工互动。我让 Claude Code 创建所有我们想要处理的较小问题的 HTML 报告。如果它对我有任何问题，我需要澄清它们并给出完成...