Флоу работы с AI coding agent в 2026, если кто в танке:

• пришла идея что-то большое запрогать — пишешь идею в Claude Code:

… Let’s have a discussion and you can interview me.

• просишь сгенерировать спеку + implementation plan и положить в specs/*.md:

 … Update specs/*.md and create implementation plan bullet points and cite the specification for lookup source or source code that needs to be adjusted

• открываешь руками спеку и план разработки - тюнишь, если надо
• ОТКРЫВАЕШЬ НОВЫЙ ЧАТ (очищаешь контекст, no context rot, no compaction)

и пишешь файл prompt.md:

study specs/readme.md
study specs/*my-new-feature*.md and pick the most important thing to do

~ дальше по вкусу добавляешь
author property based tests or unit tests (which ever is best)
after making the changes to the files run the tests
пуш в мастер деплой в прод если balls are big enough

и запускаешь:

while :; do cat prompt.md | claude —dangerously-skip-permissions;done

если тупит — просто отредактируйте prompt.md или spec.

📟 Прилетело из @danokhlopkov

Glider Fi: ончейн портфолио и стратегии их ребалансировки. Оценка команды, концепта, коина, кода + практики. Стоит ли его использовать?

Например, проект позволяет удерживать активы в определённом процентном соотношении по цене или даже устанавливать условия.
Заинтересовал своим уникальным функционалом, а также реализацией ожидаемого многими функционала ребалансируемых портфелей.

Читать в Teletype, читать в Paragraph.

Общий итог
• Команда: 4 из 5: команда публична, но ссылки и информации на сайте нет. Большинство участников обладают опытом на текущей или смежных должностях.
Соцсети активные (за исключением Youtube), и на вопросы отвечают корректно & быстро.

• Концепт: 3 из 5: функционал интересный и уникальный. Но не описано, каким образом проект управляет смарт-кошельком пользователя со стратегией: нода это, централизованный сервер или оракул... Хорошо хоть выдаются сессионные ключи для управления стратегией без возможности вывода со смарт-кошелька - это повышает безопасность.
Также нет анализа рынка, конкурентов и спроса.

• Коин: 3 из 5: токена и токеномики нет, но есть поинт программа. Также есть инвестиции, в том числе от известных фондов (например, A16Z и Uniswap). Но сумма всего 4 МЛН (по данным Cryptorank).

• Код: 1 из 5. Он закрыт (нет репозиториев, в том числе основного; невозможно оценить активность разработки). Есть аудиты смарт-кошелька, но это от других разработчиков: к проекту не относится. У самого Glider Fi их нет.

• Практика: 4 из 5: уникальный функционал, можно сделать почти любую стратегию управления портфолио. Почти, потому что ребалансирование при изменение цены на 10% в USDC и обратно не смог.
Все блоки конструктора понятны, но в if/else принцип работы не совсем ясен.
Также важно, что депозит у топ 1 стратегии всего около 1,2 МЛН $: считаю, что не стоит выделять сюда существенную сумму: максимум 1% от портфеля - это мой максимальный риск участия в проекте.

Итоговая оценка - 15 из 25 баллов: слабовато.

Читать в Teletype, читать в Paragraph.

Буду рад распространению обзора.



Как вам проект? Кто уже тестировал подобные ребалансируемые портфели - что оказалось неожиданным на практике?

P. S. Коротко по терминам. Ончейн данные - это реальные действия и балансы, зафиксированные в блокчейне. Нода или оракул - инфраструктура, через которую проект получает данные или исполняет логику стратегии. Сессионные ключи - временные права на управление стратегией без доступа к средствам пользователя. Ребалансировка - автоматическое приведение портфеля к заданным долям активов.

📟 Прилетело из @blind_dev

GM! Четвёртый месяц без фуллтайма. LinkedIn не сдаётся – офферы, рекрутеры

Но я пока сохраняю приоритет на свои проекты:
- AI-ассистент – много прогресса с начала года
- Дельта нейтралки на prediction маркетах
- Попытка в offline продукт
- Диджеинг

но DeFi по-прежнему в сердечке. Aqua от 1inch – один из проектов, за которым интересно следить из фундаментальных новинок. Писал про shared liquidity месяц назад.

Сегодня пришел пуш от ассистента, что с предыдущего поста в Telegram уже прошел месяц. Пора посмотреть что нового. А тут как раз Space для разработчиков – послушаем что готово и какие продукты билдить поверх.

Пятница, 16 января, 19:00 мск – https://x.com/1inchdevs/status/2011131896139563088
Aqua docs – https://portal.1inch.dev/documentation/aqua

📟 Прилетело из @insuline_eth

Чекер OWLTO

https://claim.owlto.finance/

Чат | Support | Market
Pelican | HiddenCode [EN]

📟 Прилетело из @hidden_coding

Если кто-то еще ждет дропа от трояна, рекомендую поставить трекеры на этот кош - J4Fa7LMUsVZQAcczPeH7chtU3ZzWufFtADKUrepMGwFu

С него в основном фандился кошелек для раздачи, мб поменяют

Также можете последить за этим кошельком - 4U4cAx8vwYKTXZqzggTyW6ZgAE61d26ZSz72kmqtJhGq

Этим фандился первый кош

📟 Прилетело из @dolbaebskicode

Это один из самых смартовых каналов на рынке

Читаю Флаву уже больше полугода и регулярно нахожу полезную информацию по крипте, стиму. Плюс много мыслей о жизни и мышлении. Ну и, конечно, он постоянно на пассиве лутает с этих ниш вполне приличные суммы.

Без воды разборы ниш, идеи и подходы, которые реально можно применять и зарабатывать на этом. Если вам интересна не только лудка канал точно зайдёт)

https://t.iss.one/+UifWe9e9v7xkNGQy

#реклама

📟 Прилетело из @hidden_coding

Алгоритмы. Рекурсия

По предыдущему посту я понял, чтобы объяснить более менее детально какую-либо тему, приходится расписывать все куда детальнее, чем во многих гайдах и обзорах. Поэтому посты по алгоритмам будут большие, но оно того стоит. Сегодня мы поговорим о рекурсии простым языком.

Понятие рекурсии можно представить как образ из мира зеркал: когда одно зеркало отражается в другом, и это отражение, в свою очередь, находит своё отражение, создавая уходящую в бесконечность череду образов. В программировании рекурсия действует схожим образом — это техника, при которой функция для решения задачи вызывает сама себя. Хотя идея может показаться необычной, при правильном применении она становится мощным и элегантным инструментом.

Для корректной работы любой рекурсивной функции необходимы два фундаментальных компонента. Во-первых, это базовый случай — условие остановки, которое предотвращает бесконечный цикл вызовов. Его можно сравнить с последней ступенькой лестницы: достигнув её, вы прекращаете движение. Во-вторых, требуется рекурсивный шаг — вызов функцией самой себя, но с изменёнными входными данными, которые должны гарантированно приближать выполнение к базовому случаю. Это подобно каждому следующему шагу вниз по лестнице, который сокращает оставшееся до низа расстояние.

Рассмотрим простейшую иллюстрацию — функцию обратного отсчёта от заданного числа до единицы. Её логика наглядно демонстрирует оба принципа.

def count_down(n):
    # Базовый случай: когда достигли 0, останавливаемся
    if n == 0:
        print("Готово!")
        return
    
    # Выводим текущее число
    print(n)
    
    # Рекурсивный шаг: вызываем функцию с n-1
    count_down(n - 1)

count_down(5)

Вывод этой программы будет последовательным:

5
4
3
2
1
Готово!

Внутри этого процесса происходит следующее: вызов count_down(5) приводит к выводу числа 5 и новому вызову count_down(4). Этот процесс вкладывается, подобно матрёшкам, пока вызов count_down(0) не достигнет базового случая, выведет "Готово!" и не начнёт возвращать управление обратно по цепочке предыдущих вызовов.

Классическим примером, раскрывающим суть рекурсивного мышления, является вычисление факториала числа n, обозначаемого как n!. По определению, факториал — это произведение всех натуральных чисел от 1 до n, при этом 0! и 1! равны 1 (вообще не так чтобы равны, посто принято такое равенство для удобства расчетов). Ключевое наблюдение здесь — рекурсивная природа операции: факториал любого числа n можно выразить через факториал меньшего числа, а именно n! = n * (n-1)!. Это и становится основой для алгоритма.

def factorial(n):
    # Базовый случай
    if n == 0 or n == 1:
        return 1
    
    # Рекурсивный шаг
    return n * factorial(n - 1)

print(factorial(5))  # 120

# Для значения 3

factorial(3)
│
├─ factorial(2)  ← добавляется в стек
│  │
│  ├─ factorial(1)  ← добавляется в стек
│  │  └─ возвращает 1  ← снимается со стека
│  │
│  └─ возвращает 2  ← снимается со стека
│
└─ возвращает 6  ← снимается со стека

# Стек вызовов для factorial(3):

Шаг 1: [factorial(3)]
Шаг 2: [factorial(3), factorial(2)]
Шаг 3: [factorial(3), factorial(2), factorial(1)]
Шаг 4: [factorial(3), factorial(2)]  ← factorial(1) вернул результат
Шаг 5: [factorial(3)]  ← factorial(2) вернул результат
Шаг 6: []  ← factorial(3) вернул результат

Пошаговое выполнение функции для factorial(5) раскладывается в цепочку отложенных умножений: 5 * factorial(4), затем 5 * (4 * factorial(3)), и так далее, пока вычисление не дойдёт до базового случая factorial(1), который возвращает 1. После этого цепочка начинает сворачиваться, производя последовательные умножения: 2 * 1 = 2, 3 * 2 = 6, 4 * 6 = 24 и, наконец, 5 * 24 = 120.

Эта же логика применима ко множеству других задач. Например, для вычисления суммы всех чисел от 1 до n.

def sum_numbers(n):
    # Базовый случай
    if n == 0:
        return 0
    
    # Рекурсивный шаг
    return n + sum_numbers(n - 1)

print(sum_numbers(5))  # 15 (5+4+3+2+1)

Аналогично работает возведение числа в натуральную степень.

📟 Прилетело из @solidityset

def power(base, exponent):
    # Базовый случай
    if exponent == 0:
        return 1
    
    # Рекурсивный шаг
    return base * power(base, exponent - 1)

print(power(2, 3))  # 8 (2 * 2 * 2)

Или определение длины строки без использования встроенных функций.

def string_length(s):
    # Базовый случай: пустая строка
    if s == "":
        return 0
    
    # Рекурсивный шаг: убираем первый символ и считаем остаток
    return 1 + string_length(s[1:])

print(string_length("hello"))  # 5

Работу рекурсивных вызовов удобно визуализировать в виде дерева, где каждый новый вызов порождает ветви, ведущие к базовым случаям, после чего результаты начинают подниматься вверх, к корневому вызову.

Механизм, обеспечивающий возможность таких вложенных вызовов, называется стеком вызовов. Это специальная область памяти, организованная по принципу LIFO ("последним пришёл — первым ушёл"), подобно стопке тарелок. Каждый новый вызов функции помещает в стек свой контекст (аргументы, локальные переменные, место возврата). Когда функция завершает работу, её контекст извлекается из вершины стека, и выполнение продолжается с предыдущего вызова. При глубокой рекурсии стек может исчерпать свой лимит, что приводит к ошибке переполнения стека. Каждый рекурсивный вызов занимает память, поэтому важно, чтобы алгоритм гарантированно сходился к базовому случаю.

Рассмотрим практический вопрос: как написать рекурсивную функцию для вычисления n-го числа Фибоначчи? Последовательность Фибоначчи задаётся правилами: F(0) = 0, F(1) = 1, а для n > 1 каждое число равно сумме двух предыдущих: F(n) = F(n-1) + F(n-2). Это определение напрямую ложится на рекурсивный алгоритм.

def fibonacci(n):
    # Базовые случаи
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    # Рекурсивный шаг
    return fibonacci(n - 1) + fibonacci(n - 2)

# Примеры
print(fibonacci(0))   # 0
print(fibonacci(1))   # 1
print(fibonacci(5))   # 5
print(fibonacci(10))  # 55

**Почему так медленно?**

Посмотрим на дерево вызовов для fibonacci(5):

fib(5)
/ \
fib(4) fib(3)
/ \ / \
fib(3) fib(2) fib(2) fib(1)
/ \ / \ / \
fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
/ \
fib(1) fib(0)

Однако у этой наивной реализации есть серьёзный недостаток — экспоненциальная временная сложность O(2^n). Это происходит из-за колоссального количества повторных вычислений одних и тех же значений, что хорошо видно на дереве вызовов для `fibonacci(5)`, где, например, `fibonacci(3)` вычисляется несколько раз. Для оптимизации применяют технику мемоизации — сохранения результатов предыдущих вычислений в кеше (словаре), чтобы не считать их заново.

```python
def fibonacci_memo(n, memo={}):
    # Если уже вычисляли, берем из кеша
    if n in memo:
        return memo[n]
    
    # Базовые случаи
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    # Вычисляем и сохраняем результат
    memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
    return memo[n]

print(fibonacci_memo(50))  # Работает быстро!

С мемоизацией сложность снижается до линейной O(n), поскольку каждое значение вычисляется только один раз.

Это подводит к обсуждению недостатков рекурсивного подхода в сравнении с итеративным (циклы). Главные минусы рекурсии — повышенный расход памяти из-за использования стека вызовов, риск его переполнения при большой глубине, более низкая скорость из-за накладных расходов на вызов функции, а также потенциальная сложность отладки. Итеративные решения обычно более эффективны по памяти и быстродействию для задач, которые можно просто выразить через циклы. Например, вычисление факториала с помощью цикла не требует хранения цепочки вызовов в стеке.

📟 Прилетело из @solidityset

Тем не менее, рекурсия остаётся незаменимым инструментом для задач, имеющих естественную рекурсивную структуру данных или логики. Она идеально подходит для обхода древовидных структур (каталогов файловой системы), реализации алгоритмов "разделяй и властвуй" (быстрая сортировка, бинарный поиск) и решения таких задач, как Ханойские башни. Выбор между рекурсией и итерацией часто является компромиссом между читаемостью, простотой выражения идеи алгоритма и требованиями к производительности и ресурсам.

#algorithm

📟 Прилетело из @solidityset

Алгоритмы. Рекурсия

По предыдущему посту я понял, чтобы объяснить более менее детально какую-либо тему, приходится расписывать все куда детальнее, чем во многих гайдах и обзорах. Поэтому посты по алгоритмам будут большие, но оно того стоит. Сегодня мы поговорим о рекурсии простым языком.

Понятие рекурсии можно представить как образ из мира зеркал: когда одно зеркало отражается в другом, и это отражение, в свою очередь, находит своё отражение, создавая уходящую в бесконечность череду образов. В программировании рекурсия действует схожим образом — это техника, при которой функция для решения задачи вызывает сама себя. Хотя идея может показаться необычной, при правильном применении она становится мощным и элегантным инструментом.

Для корректной работы любой рекурсивной функции необходимы два фундаментальных компонента. Во-первых, это базовый случай — условие остановки, которое предотвращает бесконечный цикл вызовов. Его можно сравнить с последней ступенькой лестницы: достигнув её, вы прекращаете движение. Во-вторых, требуется рекурсивный шаг — вызов функцией самой себя, но с изменёнными входными данными, которые должны гарантированно приближать выполнение к базовому случаю. Это подобно каждому следующему шагу вниз по лестнице, который сокращает оставшееся до низа расстояние.

Рассмотрим простейшую иллюстрацию — функцию обратного отсчёта от заданного числа до единицы. Её логика наглядно демонстрирует оба принципа.

def count_down(n):
    # Базовый случай: когда достигли 0, останавливаемся
    if n == 0:
        print("Готово!")
        return
    
    # Выводим текущее число
    print(n)
    
    # Рекурсивный шаг: вызываем функцию с n-1
    count_down(n - 1)

count_down(5)

Вывод этой программы будет последовательным:

5
4
3
2
1
Готово!

Внутри этого процесса происходит следующее: вызов count_down(5) приводит к выводу числа 5 и новому вызову count_down(4). Этот процесс вкладывается, подобно матрёшкам, пока вызов count_down(0) не достигнет базового случая, выведет "Готово!" и не начнёт возвращать управление обратно по цепочке предыдущих вызовов.

Классическим примером, раскрывающим суть рекурсивного мышления, является вычисление факториала числа n, обозначаемого как n!. По определению, факториал — это произведение всех натуральных чисел от 1 до n, при этом 0! и 1! равны 1 (вообще не так чтобы равны, просто принято такое равенство для удобства расчетов). Ключевое наблюдение здесь — рекурсивная природа операции: факториал любого числа n можно выразить через факториал меньшего числа, а именно n! = n * (n-1)!. Это и становится основой для алгоритма.

def factorial(n):
    # Базовый случай
    if n == 0 or n == 1:
        return 1
    
    # Рекурсивный шаг
    return n * factorial(n - 1)

print(factorial(5))  # 120

# Для значения 3

factorial(3)
│
├─ factorial(2)  ← добавляется в стек
│  │
│  ├─ factorial(1)  ← добавляется в стек
│  │  └─ возвращает 1  ← снимается со стека
│  │
│  └─ возвращает 2  ← снимается со стека
│
└─ возвращает 6  ← снимается со стека

# Стек вызовов для factorial(3):

Шаг 1: [factorial(3)]
Шаг 2: [factorial(3), factorial(2)]
Шаг 3: [factorial(3), factorial(2), factorial(1)]
Шаг 4: [factorial(3), factorial(2)]  ← factorial(1) вернул результат
Шаг 5: [factorial(3)]  ← factorial(2) вернул результат
Шаг 6: []  ← factorial(3) вернул результат

Пошаговое выполнение функции для factorial(5) раскладывается в цепочку отложенных умножений: 5 * factorial(4), затем 5 * (4 * factorial(3)), и так далее, пока вычисление не дойдёт до базового случая factorial(1), который возвращает 1. После этого цепочка начинает сворачиваться, производя последовательные умножения: 2 * 1 = 2, 3 * 2 = 6, 4 * 6 = 24 и, наконец, 5 * 24 = 120.

Эта же логика применима ко множеству других задач. Например, для вычисления суммы всех чисел от 1 до n.

def sum_numbers(n):
    # Базовый случай
    if n == 0:
        return 0
    
    # Рекурсивный шаг
    return n + sum_numbers(n - 1)

print(sum_numbers(5))  # 15 (5+4+3+2+1)

Аналогично работает возведение числа в натуральную степень.

📟 Прилетело из @solidityset

def power(base, exponent):
    # Базовый случай
    if exponent == 0:
        return 1
    
    # Рекурсивный шаг
    return base * power(base, exponent - 1)

print(power(2, 3))  # 8 (2 * 2 * 2)

Или определение длины строки без использования встроенных функций.

def string_length(s):
    # Базовый случай: пустая строка
    if s == "":
        return 0
    
    # Рекурсивный шаг: убираем первый символ и считаем остаток
    return 1 + string_length(s[1:])

print(string_length("hello"))  # 5

Работу рекурсивных вызовов удобно визуализировать в виде дерева, где каждый новый вызов порождает ветви, ведущие к базовым случаям, после чего результаты начинают подниматься вверх, к корневому вызову.

Механизм, обеспечивающий возможность таких вложенных вызовов, называется стеком вызовов. Это специальная область памяти, организованная по принципу LIFO ("последним пришёл — первым ушёл"), подобно стопке тарелок. Каждый новый вызов функции помещает в стек свой контекст (аргументы, локальные переменные, место возврата). Когда функция завершает работу, её контекст извлекается из вершины стека, и выполнение продолжается с предыдущего вызова. При глубокой рекурсии стек может исчерпать свой лимит, что приводит к ошибке переполнения стека. Каждый рекурсивный вызов занимает память, поэтому важно, чтобы алгоритм гарантированно сходился к базовому случаю.

Рассмотрим практический вопрос: как написать рекурсивную функцию для вычисления n-го числа Фибоначчи? Последовательность Фибоначчи задаётся правилами: F(0) = 0, F(1) = 1, а для n > 1 каждое число равно сумме двух предыдущих: F(n) = F(n-1) + F(n-2). Это определение напрямую ложится на рекурсивный алгоритм.

def fibonacci(n):
    # Базовые случаи
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    # Рекурсивный шаг
    return fibonacci(n - 1) + fibonacci(n - 2)

# Примеры
print(fibonacci(0))   # 0
print(fibonacci(1))   # 1
print(fibonacci(5))   # 5
print(fibonacci(10))  # 55

# Почему так медленно?

Посмотрим на дерево вызовов для fibonacci(5):

                    fib(5)
                   /      \
              fib(4)      fib(3)
              /    \      /    \
          fib(3) fib(2) fib(2) fib(1)
          /   \   /  \   /  \
      fib(2) fib(1) fib(1) fib(0) fib(1) fib(0)
      /   \
  fib(1) fib(0)

Однако у этой наивной реализации есть серьёзный недостаток — экспоненциальная временная сложность O(2^n). Это происходит из-за колоссального количества повторных вычислений одних и тех же значений, что хорошо видно на дереве вызовов для fibonacci(5), где, например, fibonacci(3) вычисляется несколько раз. Для оптимизации применяют технику мемоизации — сохранения результатов предыдущих вычислений в кеше (словаре), чтобы не считать их заново.

def fibonacci_memo(n, memo={}):
    # Если уже вычисляли, берем из кеша
    if n in memo:
        return memo[n]
    
    # Базовые случаи
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    # Вычисляем и сохраняем результат
    memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo)
    return memo[n]

print(fibonacci_memo(50))  # Работает быстро!

С мемоизацией сложность снижается до линейной O(n), поскольку каждое значение вычисляется только один раз.

Это подводит к обсуждению недостатков рекурсивного подхода в сравнении с итеративным (циклы). Главные минусы рекурсии — повышенный расход памяти из-за использования стека вызовов, риск его переполнения при большой глубине, более низкая скорость из-за накладных расходов на вызов функции, а также потенциальная сложность отладки. Итеративные решения обычно более эффективны по памяти и быстродействию для задач, которые можно просто выразить через циклы. Например, вычисление факториала с помощью цикла не требует хранения цепочки вызовов в стеке.

📟 Прилетело из @solidityset

Тем не менее, рекурсия остаётся незаменимым инструментом для задач, имеющих естественную рекурсивную структуру данных или логики. Она идеально подходит для обхода древовидных структур (каталогов файловой системы), реализации алгоритмов "разделяй и властвуй" (быстрая сортировка, бинарный поиск) и решения таких задач, как Ханойские башни. Выбор между рекурсией и итерацией часто является компромиссом между читаемостью, простотой выражения идеи алгоритма и требованиями к производительности и ресурсам.

#algorithm

📟 Прилетело из @solidityset

FUN: первый лайфчендж 2026?

Думаю, вы уже видели скрины с сумасшедшими профитами $FUN на ASTER DEX.

Если кратко, то маркетмейкер $FUN на ASTER парсил цену с другого токена, который на 99,9% торговался ниже, чем $FUN на других биржах.

Те, у кого была ликва на астере или те кто самый первый успел депнуть смогли заливалиться на самом дне пролива, после чего цену обратно вернули вверх и сравняли спред со всеми биржами.

Людям удалось забрать 20-50х на сайз, что очень вкусно и я рад за тех, кому это удалось.

Для остальных рекомендую держать деньги на: всех СЕХ, а так же Lighter, HL, Aster. И ждать свой лайфчендж.

📟 Прилетело из @hidden_coding

Провели вертикальный тг стрим с вайбкодингом игрульки @blockwallbot

добавили:
• красивые темы
• рефералку
• фикс багов
• онбординг

Кто был — расскажите, как вам формат? Что запрогать дальше? Темы для будущих стримов?

Запись стрима грузится в комменты

📟 Прилетело из @danokhlopkov

Vercel Labs выкатили json-render – библиотеку для генерации UI через промпты.

Проблема: когда AI генерит интерфейс — это рулетка. Может выдать несуществующий компонент, кривой JSON, XSS в придачу. json-render ставит модель в рамки: вот каталог компонентов, вот схема – генерируй только из этого. Нет в каталоге – не рендерим. Tool calling, только для UI.

У ребят из Onchain Divers индексеры по Solana, Hyperliquid, Polymarket — данных море. Сейчас чтобы сделать к этому интерфейс — либо пилишь фронт руками, либо агент отвечает текстом. С json-render агент рисует готовый UI: "покажи все свопы больше 10 SOL на Raydium для токена за неделю" → таблица с интерактивными фильтрами, не простыня текста. "Топ кошельков по объёму на Hyperliquid" → график. Всё с валидацией по схеме.

Генеративный UI близок. Первые шаги, но направление понятно.

github.com/vercel-labs/json-render

📟 Прилетело из @insuline_eth