{"as_of":"2026-08-21T07:50:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:ccf95074990b9a0caedb30e1b45bfeca53bdce403a8d683da7b5425f31540076","coverage":[{"denominator":78,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":78,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-05T23:02:03.507900Z","state":"measured"},{"denominator":78,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":78,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-21T06:32:19.484+00:00","state":"measured"},{"denominator":0,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":0,"source":"paper_references, paper_reference_links","source_observed_at":null,"state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":0,"source":"cited_works","source_observed_at":null,"state":"measured"}],"external_citation_measurements":[],"inbound":[],"links":{"evidence":"/evidence","html":"/paper/2508.06017/citation-record","integrity":"/paper/2508.06017/integrity","json":"/paper/2508.06017/citation-record.json","paper":"/paper/2508.06017"},"outbound":[{"citation":{"cited_paper":{"arxiv_id":"2412.08905","last_updated":"2024-12-12T03:37:41Z","snapshot_observed_at":"2026-08-20T14:44:18.211453Z","submitted_at":"2024-12-12T03:37:41Z","title":"Phi-4 Technical Report","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2412.08905","snapshot_observed_at":"2026-08-05T23:01:58.560944Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":1,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.560944Z"},"links":{"cited_paper":"/paper/2412.08905","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:7de39ba11282fac26dc6befcb0ab4dafc41fcbe7d7c0171a2efc03ffff859b68","observation_id":"50f898b4-b1d6-4e41-8235-7230ffff109c","resolution":{"observed_at":"2026-08-05T23:01:58.560944Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2303.08774","last_updated":"2024-03-04T06:01:33Z","snapshot_observed_at":"2026-08-17T09:58:46.058102Z","submitted_at":"2023-03-15T17:15:04Z","title":"GPT-4 Technical Report","version":6},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2303.08774","snapshot_observed_at":"2026-08-05T23:01:58.607809Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":2,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.607809Z"},"links":{"cited_paper":"/paper/2303.08774","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:a96ddb50a84107accef0ccc939b094400df2fec54711c1765dfebaf80393239e","observation_id":"a9fe5506-6a74-48c5-98b0-39262b6d0354","resolution":{"observed_at":"2026-08-05T23:01:58.607809Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.733890Z","title":null,"venue":null,"work_id":"45d15226-561a-49b2-9366-5d1f25c34254","year":2017},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":3,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.678809Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:f631e5c645f820a961cc4c4c7c6b438da1c0437a8e4816a4d4557704baffd077","observation_id":"6e2b4d8b-357e-4917-a6ee-2bad019f5700","resolution":{"observed_at":"2026-08-05T23:02:04.736815Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2503.08679","last_updated":"2026-06-16T17:36:22Z","snapshot_observed_at":"2026-08-16T12:51:00.810519Z","submitted_at":"2025-03-11T17:56:30Z","title":"Chain-of-Thought Reasoning In The Wild Is Not Always Faithful","version":6},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2503.08679","snapshot_observed_at":"2026-08-05T23:01:58.755678Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":4,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.755678Z"},"links":{"cited_paper":"/paper/2503.08679","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:3a33da2495ffed89523019229ff0c2995a7c44df0e85d027e5568ab6ace16e47","observation_id":"ecf95395-fedf-4c66-8987-a59e164ad1b1","resolution":{"observed_at":"2026-08-05T23:01:58.755678Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2503.11926","last_updated":"2025-03-14T23:50:34Z","snapshot_observed_at":"2026-08-17T15:42:03.133713Z","submitted_at":"2025-03-14T23:50:34Z","title":"Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2503.11926","snapshot_observed_at":"2026-08-05T23:01:58.853181Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":5,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.853181Z"},"links":{"cited_paper":"/paper/2503.11926","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:49fa3b50000839306db0f5c4b306e1df28fdd9f20ddc12d5dcc0255aa623facc","observation_id":"e8823953-c0e6-4693-a549-9a362393cc88","resolution":{"observed_at":"2026-08-05T23:01:58.853181Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.725903Z","title":null,"venue":null,"work_id":"4d6cb7a2-0201-4f33-a6b5-25df3c6ce52c","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":6,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:58.948222Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:95684f4401481a6e9d2bb9eaf8f8e8bcd6c9df296a25f45d3cb1abe54800c7d4","observation_id":"de832e46-2797-485a-bb68-bb2abdcde220","resolution":{"observed_at":"2026-08-05T23:02:04.728692Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.718060Z","title":null,"venue":null,"work_id":"b265882a-1f4c-4f0d-b00c-0c7f49468b95","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":7,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.082884Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:44d5e66603197607a2797ef9b00260d4febaa19b2def74cf9653f4b9a5b8eb23","observation_id":"f2b6890f-a832-4e31-ad17-80fd3cf644c8","resolution":{"observed_at":"2026-08-05T23:02:04.720711Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2502.05242","last_updated":"2026-05-27T09:11:42Z","snapshot_observed_at":"2026-08-13T15:11:30.438627Z","submitted_at":"2025-02-07T13:25:33Z","title":"Beyond External Monitors: Enhancing Transparency of Large Language Models for Easier Monitoring","version":3},"cited_work":{"arxiv_id":"2502.05242","doi":null,"metadata_source":"pith","pith_arxiv_id":"2502.05242","snapshot_observed_at":"2026-08-05T23:02:04.281602Z","title":"Beyond External Monitors: Enhancing Transparency of Large Language Models for Easier Monitoring","venue":"cs.CL","work_id":"c2e31a45-6fb4-4b67-a308-a96d7775593d","year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":8,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.215909Z"},"links":{"cited_paper":"/paper/2502.05242","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:36b7be4e413760224dcf95588e349b175a6dce1af92e43571d6246fe3c3a86b3","observation_id":"0bdfb9f2-0a78-4996-bd33-6a36b60098b2","resolution":{"observed_at":"2026-08-05T23:02:04.284765Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2505.05410","last_updated":"2025-05-08T16:51:43Z","snapshot_observed_at":"2026-08-15T05:29:13.739206Z","submitted_at":"2025-05-08T16:51:43Z","title":"Reasoning Models Don't Always Say What They Think","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2505.05410","snapshot_observed_at":"2026-08-05T23:01:59.326685Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":9,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.326685Z"},"links":{"cited_paper":"/paper/2505.05410","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:a584397ddcbe32ec755ba5be88b09dc3cc1061ad437bfe93ae4f61ced0f7adc8","observation_id":"640802df-da7a-4574-9bb4-b6d7ea69a610","resolution":{"observed_at":"2026-08-05T23:01:59.326685Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.709688Z","title":"Claude Sonnet 4","venue":null,"work_id":"700df791-76ef-42f8-bd47-21b6f51bd518","year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":10,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.448621Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:f33f17a4b8e5e8c8bb5728ada5420c1cfe38a715b93fa327d3e32417a9f3b433","observation_id":"92df359f-7449-4066-8213-e8bdef3b39a4","resolution":{"observed_at":"2026-08-05T23:02:04.712609Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.701796Z","title":null,"venue":null,"work_id":"dbbe7261-b2ed-4133-86fc-c39c8a02e7c4","year":2019},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":11,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.586647Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:01aee2271cb99e87b722e2e2794344c09cffabcf680dbe7c2062e53f8ff05c7d","observation_id":"91f9981b-bc37-4988-8268-e867008239ee","resolution":{"observed_at":"2026-08-05T23:02:04.704499Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.693842Z","title":null,"venue":null,"work_id":"6598e0e3-4637-40e8-bb0d-7aed121c1c66","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":12,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.700192Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:e09683bcc60b6d65bf673476bb80bbcda4acc3a16e3f00ac0fac945cbfca18f0","observation_id":"a599651f-910a-4357-8b64-7a42aa328405","resolution":{"observed_at":"2026-08-05T23:02:04.696593Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.685842Z","title":null,"venue":null,"work_id":"c9fb0b7b-0797-4fab-a9da-ca23d6f12268","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":13,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.763442Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:11fc0a4c0dd82b94935dd429827450f34d73e9862a6fc004aea13a6709d982b8","observation_id":"8727e246-819f-428a-8efb-448d4f0c59c4","resolution":{"observed_at":"2026-08-05T23:02:04.688445Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2406.12334","last_updated":"2025-08-23T18:44:57Z","snapshot_observed_at":"2026-08-16T13:41:57.331250Z","submitted_at":"2024-06-18T06:59:24Z","title":"What Did I Do Wrong? Quantifying LLMs' Sensitivity and Consistency to Prompt Engineering","version":4},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2406.12334","snapshot_observed_at":"2026-08-05T23:01:59.849579Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":14,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.849579Z"},"links":{"cited_paper":"/paper/2406.12334","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:18ecf10054b84d2a37beeb8492c078a9a1f24307a91949e077cf1c9f6d61015f","observation_id":"4f199e73-cd56-421b-91c0-3e0df4fdbbd3","resolution":{"observed_at":"2026-08-05T23:01:59.849579Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2404.10362","last_updated":"2024-05-06T23:21:57Z","snapshot_observed_at":"2026-08-16T14:00:35.314936Z","submitted_at":"2024-04-16T07:53:28Z","title":"3DGen: AI-Assisted Generation of Provably Correct Binary Format Parsers","version":2},"cited_work":{"arxiv_id":"2404.10362","doi":null,"metadata_source":"pith","pith_arxiv_id":"2404.10362","snapshot_observed_at":"2026-08-05T23:02:04.252074Z","title":"3DGen: AI-Assisted Generation of Provably Correct Binary Format Parsers","venue":"cs.SE","work_id":"9357b753-ab92-461f-82c9-8c2fa1f0550f","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":15,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.896172Z"},"links":{"cited_paper":"/paper/2404.10362","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:429e53e6622e632fdf1e3118c0a429d581888280db6584efaa70ef2fcdd37cc4","observation_id":"4ef85210-911c-4c14-90ff-4d067b3d71bd","resolution":{"observed_at":"2026-08-05T23:02:04.255954Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2501.18160","last_updated":"2025-05-29T22:08:26Z","snapshot_observed_at":"2026-08-20T02:37:55.059415Z","submitted_at":"2025-01-30T05:56:30Z","title":"RepoAudit: An Autonomous LLM-Agent for Repository-Level Code Auditing","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2501.18160","snapshot_observed_at":"2026-08-05T23:01:59.966598Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":16,"source":"pdf_text","source_observed_at":"2026-08-05T23:01:59.966598Z"},"links":{"cited_paper":"/paper/2501.18160","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b028a0110efc366a271982764372b5d23da6e273ca973e4b7d0b0e0ba07d2202","observation_id":"d964caef-9ab5-43ef-9a77-8b2e872678f2","resolution":{"observed_at":"2026-08-05T23:01:59.966598Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.678172Z","title":null,"venue":null,"work_id":"5f1d74ae-cf49-4dd1-8a2e-f6763b3341a7","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":17,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.072330Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:9d73320c4432cb6573683ad240681a6723ff88cb7c9dbff007d6c79c112050a5","observation_id":"43edc756-3ca9-4f02-9807-c1516b99bb92","resolution":{"observed_at":"2026-08-05T23:02:04.680741Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.669933Z","title":null,"venue":null,"work_id":"ba4e9a1a-089d-4b2b-82ac-4ad1f4aef601","year":2014},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":18,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.183801Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:758bdc8dc5e149ad0bf3521de60982b6a122fec36a7571a1ec25a5da7d5cf07d","observation_id":"bb99b029-1c3f-4468-9f61-694043b7ab22","resolution":{"observed_at":"2026-08-05T23:02:04.672876Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.661486Z","title":null,"venue":null,"work_id":"b7450762-09ff-4c8f-baa1-a242a05a1dc8","year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":19,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.260916Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:87f35dfbbcb65442a4e30ab30ab8946b80cf31ad93a3da4c032b3d5dced0f8eb","observation_id":"be48ef1c-7f46-49c2-ae06-e9dff4505d9c","resolution":{"observed_at":"2026-08-05T23:02:04.664269Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.643328Z","title":null,"venue":null,"work_id":"42c46efd-2785-41b7-8bed-9e86698d365f","year":2021},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":20,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.503252Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:18f1a506d4452caf3e9532a76b80dcd31a9082817b2178ac736f89a62132329d","observation_id":"6fc88a3e-7f92-4ef2-b29f-7684d1f1d705","resolution":{"observed_at":"2026-08-05T23:02:04.645975Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"1910.07387","last_updated":"2019-10-29T21:14:22Z","snapshot_observed_at":"2026-07-06T08:30:01.929590Z","submitted_at":"2019-10-16T14:52:51Z","title":"Do Explanations Reflect Decisions? A Machine-centric Strategy to Quantify the Performance of Explainability Algorithms","version":2},"cited_work":{"arxiv_id":"1910.07387","doi":null,"metadata_source":"pith","pith_arxiv_id":"1910.07387","snapshot_observed_at":"2026-08-05T23:02:04.155280Z","title":"Do Explanations Reflect Decisions? A Machine-centric Strategy to Quantify the Performance of Explainability Algorithms","venue":"cs.LG","work_id":"746ebc68-0aa0-40e4-ab96-33ff7ef2826b","year":2019},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":21,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.635433Z"},"links":{"cited_paper":"/paper/1910.07387","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:0216d1c0db66fd50f8e3231ed12f37d248faea5a4d1eddf8030113d8471d823b","observation_id":"a8edf053-3245-456c-90de-d7edb65e5123","resolution":{"observed_at":"2026-08-05T23:02:04.232917Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2410.03837","last_updated":"2024-10-23T22:22:20Z","snapshot_observed_at":"2026-08-16T13:12:28.889892Z","submitted_at":"2024-10-04T18:05:22Z","title":"Learning Code Preference via Synthetic Evolution","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2410.03837","snapshot_observed_at":"2026-08-05T23:02:00.785817Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":22,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.785817Z"},"links":{"cited_paper":"/paper/2410.03837","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:61f35d657493e5bde6c7ca47bfe32a1452ed58e985df94d14226a96c095cc2b2","observation_id":"1d02fd84-6aba-4654-aeb8-bfb105fd3958","resolution":{"observed_at":"2026-08-05T23:02:00.785817Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.634783Z","title":null,"venue":null,"work_id":"c841911d-e96a-4e4a-abea-ada3520fabe4","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":23,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.941185Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:cd715d91a63c2abfacf5966cc5590081f2234c324a68077d450a52656cf5440f","observation_id":"907c35d4-ffd6-40e5-ad44-ff63ac63822f","resolution":{"observed_at":"2026-08-05T23:02:04.637970Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2411.00622","last_updated":"2024-11-01T14:27:16Z","snapshot_observed_at":"2026-08-20T02:19:30.826922Z","submitted_at":"2024-11-01T14:27:16Z","title":"Lingma SWE-GPT: An Open Development-Process-Centric Language Model for Automated Software Improvement","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2411.00622","snapshot_observed_at":"2026-08-05T23:02:01.065446Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.065446Z"},"links":{"cited_paper":"/paper/2411.00622","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:494e797d58ff6620b030aebd7f32f93ebfc181d642be09b1c251a404daa534e0","observation_id":"aa7735d6-1c47-4236-95f2-80f2d81b70df","resolution":{"observed_at":"2026-08-05T23:02:01.065446Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.626799Z","title":null,"venue":null,"work_id":"f2d0cba4-fb8d-4153-bf6d-7ab202189e9a","year":2012},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":25,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.210548Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:d8f16841a4efb91cd061006dd9ffa6a41b4e50791651a0598553b0a0cdf365fc","observation_id":"d3462ec3-bfce-400c-b2ce-27723d017c60","resolution":{"observed_at":"2026-08-05T23:02:04.629441Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.618814Z","title":null,"venue":null,"work_id":"ab4adcdc-2d24-4cf5-be95-96800a0b225f","year":2011},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":26,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.290052Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:cbb2e9c107cd6c33bfc063cdd39619c2f78fb306c6de5bd2b3d5289d3ff85dce","observation_id":"fb16f850-d916-46ab-bd5f-a2f73931971f","resolution":{"observed_at":"2026-08-05T23:02:04.621476Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.611162Z","title":null,"venue":null,"work_id":"f50dc7b9-33f2-4c2d-9742-9f12e0f1d452","year":2022},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":27,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.409466Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:1ee9f30c9ebc9fabb10d42e1e55bcf05eb029ad357bcaff2299f4a0dbf014090","observation_id":"ff79f779-8e39-4336-b34d-dc89be4eff6b","resolution":{"observed_at":"2026-08-05T23:02:04.613640Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.601863Z","title":null,"venue":null,"work_id":"237d3e4a-ab0b-416a-b7bf-ca99ca7758fd","year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":28,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.524639Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b407bea15129afcd14361041050c962e26e236a894041d88758e03343b679605","observation_id":"5aabc39e-7d12-44ce-ac07-1c4e8ff3a0f9","resolution":{"observed_at":"2026-08-05T23:02:04.605828Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.593974Z","title":null,"venue":null,"work_id":"08c98598-0c79-4c62-9cb3-ca74a411cd23","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":29,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.635715Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:12da0246960f16c2cd7fc6899900f6277e97de90acb3fcfcaadac184ecc49dff","observation_id":"418dacb9-34ef-4a24-a289-70ccbae88b72","resolution":{"observed_at":"2026-08-05T23:02:04.596556Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.585904Z","title":null,"venue":null,"work_id":"2ad192ad-d8a8-40fa-ab4a-1bd77adf34db","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":30,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.749108Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:d7dec69240c9c0fba776f0017eebf91024bb2540ee1b8b6df7890325c6f2472e","observation_id":"706799fd-714f-47f3-9cb2-2e8dd66f4713","resolution":{"observed_at":"2026-08-05T23:02:04.588613Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.577904Z","title":null,"venue":null,"work_id":"9796347f-2d4e-4ada-b21b-81c19a8e1ef5","year":2002},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":31,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.866307Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:3ec8fd8b0076aee61c835b427d9cb4cd772edd9c8c931ba1db20aff4caf2ce6c","observation_id":"ebd782cb-7c86-43c1-a25e-6fb39d95470f","resolution":{"observed_at":"2026-08-05T23:02:04.580541Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.570071Z","title":null,"venue":null,"work_id":"e4e3ec67-fb5c-4508-8247-01d2569e29de","year":1981},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":32,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:01.948764Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:92485efbc25655a91e6a5353798274ef6af6627de6626ac49ef71f0d4a06413d","observation_id":"7d2198c5-075e-4c86-9011-9ac4b116063a","resolution":{"observed_at":"2026-08-05T23:02:04.572780Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.561973Z","title":null,"venue":null,"work_id":"33e22a81-561b-4a55-8920-f9e2a0a338e5","year":1976},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":33,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.064243Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:516541ab5cc9db3e3976dd03c2849906a24f41dcf30043f69682485f0a20237d","observation_id":"94a7c836-c5aa-4884-8343-d0996d0c3338","resolution":{"observed_at":"2026-08-05T23:02:04.564659Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.553358Z","title":null,"venue":null,"work_id":"fd76d84e-d53e-4d5b-a78d-f44843571dce","year":2020},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":34,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.174954Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:e232733fbd958fe1fc47884f20335e2a95c55d78ae5f74e2cf4268db4212002e","observation_id":"f726ec4e-59f5-424d-ad2b-601164428b2c","resolution":{"observed_at":"2026-08-05T23:02:04.556401Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2308.12950","last_updated":"2024-01-31T19:47:26Z","snapshot_observed_at":"2026-08-18T03:59:39.242039Z","submitted_at":"2023-08-24T17:39:13Z","title":"Code Llama: Open Foundation Models for Code","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2308.12950","snapshot_observed_at":"2026-08-05T23:02:02.273622Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":35,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.273622Z"},"links":{"cited_paper":"/paper/2308.12950","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:77b3af763a5dbd4ff00e787aee97a9b143b58f6563c5001898798918f6adca54","observation_id":"53d481f9-936c-41fb-8b44-2c50afcf00d6","resolution":{"observed_at":"2026-08-05T23:02:02.273622Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.544598Z","title":null,"venue":null,"work_id":"1e229d69-4eb3-4446-809b-3b5e2c8df29a","year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":36,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.414751Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:5471ae95806fb6b91f89d812c4efd3835ebc6e5549e1b487de1a78d9d8cf9305","observation_id":"39a6e6b3-971b-4f83-9561-f2a473518d3b","resolution":{"observed_at":"2026-08-05T23:02:04.547247Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.536213Z","title":null,"venue":null,"work_id":"3483c154-2425-4ef4-a5f8-ce5ac2c5ff91","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":37,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.567492Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:3c2b995a855ec3f5f31504ab0dbb46e59adbe22235b3dd2bed08d579beea0010","observation_id":"59c2981e-c245-44c3-923c-6ba79cb1ece0","resolution":{"observed_at":"2026-08-05T23:02:04.539319Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.528326Z","title":null,"venue":null,"work_id":"ccde4cce-1632-4f07-aee9-0f254880ea99","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":38,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.642558Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:4675eb0b5e64d53e2a4fddf1ad02912828f9b9bf3e3ea833330b0e8b3acb0011","observation_id":"8826abae-d9b7-41a0-ac65-a3373a84e035","resolution":{"observed_at":"2026-08-05T23:02:04.530863Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.520418Z","title":null,"venue":null,"work_id":"f5fc00b2-2522-4b73-b086-4081994f9f14","year":2022},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":39,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.720194Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:8c34c86e4362b70fd8b075244cae7456ecf788805bf3011055bac46be648c3f2","observation_id":"68dc5721-17bd-4356-96ce-903cdded592d","resolution":{"observed_at":"2026-08-05T23:02:04.523021Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2502.03014","last_updated":"2025-02-05T09:17:48Z","snapshot_observed_at":"2026-08-13T20:12:30.529999Z","submitted_at":"2025-02-05T09:17:48Z","title":"xai_evals : A Framework for Evaluating Post-Hoc Local Explanation Methods","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2502.03014","snapshot_observed_at":"2026-08-05T23:02:02.828372Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":40,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.828372Z"},"links":{"cited_paper":"/paper/2502.03014","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:cc674ac4c8715992f364d26c671d904e63c3ce3b2eeea594fc2be8a4f6cbd7d3","observation_id":"eb475848-4d90-4609-baf9-dfcd8d84d437","resolution":{"observed_at":"2026-08-05T23:02:02.828372Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.511821Z","title":null,"venue":null,"work_id":"5a9ff807-62c2-44a3-922d-2f7ae7c6a71d","year":2018},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":41,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:02.947798Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:0c6b0d4ce271151991b8e5dffb7c1dbb99fac611f59d89de4deb8b96af4d8c2a","observation_id":"487195db-f74a-45fd-82c3-7ea5f5553369","resolution":{"observed_at":"2026-08-05T23:02:04.514353Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2407.10457","last_updated":"2024-07-15T06:12:17Z","snapshot_observed_at":"2026-08-16T20:20:59.328492Z","submitted_at":"2024-07-15T06:12:17Z","title":"The Good, The Bad, and The Greedy: Evaluation of LLMs Should Not Ignore Non-Determinism","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2407.10457","snapshot_observed_at":"2026-08-05T23:02:03.070200Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":42,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.070200Z"},"links":{"cited_paper":"/paper/2407.10457","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:11fbeaa11687c24fdf10e118977275baefb45fe5a40b0356b328fc9efd651a3f","observation_id":"a54752ae-d3fb-46d3-b33a-5853707f61c2","resolution":{"observed_at":"2026-08-05T23:02:03.070200Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.503597Z","title":null,"venue":null,"work_id":"eac73360-c01a-4f14-a977-95e6299e3463","year":2020},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":43,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.143268Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:6e9a86230a53b39753ce2705f23972caa03b4a50f74b0a9c149f73c7864004a3","observation_id":"24d4529b-821f-4ce9-b107-c7d6b78cbd82","resolution":{"observed_at":"2026-08-05T23:02:04.506365Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"1906.10924","last_updated":"2019-06-26T09:10:33Z","snapshot_observed_at":"2026-08-19T18:16:38.000934Z","submitted_at":"2019-06-26T09:10:33Z","title":"Interpretable Question Answering on Knowledge Bases and Text","version":1},"cited_work":{"arxiv_id":"1906.10924","doi":null,"metadata_source":"pith","pith_arxiv_id":"1906.10924","snapshot_observed_at":"2026-08-05T23:02:03.840646Z","title":"Interpretable Question Answering on Knowledge Bases and Text","venue":"cs.CL","work_id":"1938a42c-0cca-47db-8eb3-18a5ffc67ef1","year":2019},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":44,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.249119Z"},"links":{"cited_paper":"/paper/1906.10924","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:2d416b5ceaab0cb23243b1abde93d5cdfaceda4079c09067f22f68647845df1f","observation_id":"8def7a8a-7fb0-4f8a-8590-f5fa9cad41fa","resolution":{"observed_at":"2026-08-05T23:02:03.958695Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.495176Z","title":null,"venue":null,"work_id":"772fe6b7-b7e5-4d32-906a-554c98ac130d","year":2007},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":45,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.328488Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:d429653d89b9825c5e59bec7bbda1900ad4efc747fdaca9b940ffbccc14d616d","observation_id":"76aab8f6-0aee-4493-9074-011f398068d8","resolution":{"observed_at":"2026-08-05T23:02:04.497945Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2208.00337","last_updated":"2022-07-31T02:07:33Z","snapshot_observed_at":"2026-08-16T16:42:14.043826Z","submitted_at":"2022-07-31T02:07:33Z","title":"Tai-e: A Static Analysis Framework for Java by Harnessing the Best Designs of Classics","version":1},"cited_work":{"arxiv_id":"2208.00337","doi":null,"metadata_source":"pith","pith_arxiv_id":"2208.00337","snapshot_observed_at":"2026-08-05T23:02:03.636269Z","title":"Tai-e: A Static Analysis Framework for Java by Harnessing the Best Designs of Classics","venue":"cs.PL","work_id":"149c9071-5a19-4cd7-b595-342bba793965","year":2022},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":46,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.411516Z"},"links":{"cited_paper":"/paper/2208.00337","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:116c60d10ffda28c81725b686da3158b169ec49fd2cf388408ef93c3d3e82c1c","observation_id":"f38528f1-305b-44bc-88ce-115238e39f74","resolution":{"observed_at":"2026-08-05T23:02:03.669352Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.486767Z","title":null,"venue":null,"work_id":"bb91fc2e-51e5-4c3d-803e-ffd7a1fa4cb8","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":47,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.426530Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:fba89013eeea1b6b273047248faedfef02d375cc3dc1a17277f53fc31bafcf5e","observation_id":"350d7762-3444-49a4-b406-873e8b56b427","resolution":{"observed_at":"2026-08-05T23:02:04.489357Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.478759Z","title":null,"venue":null,"work_id":"24ee0359-f608-49b0-a07f-dc5c4203beb0","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":48,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.429131Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:55976c4cac4010c6ac66b44800aea30b8bf8a37d491b77812dacb1572f884ff3","observation_id":"02162353-2319-437d-9f4a-7f060b436c09","resolution":{"observed_at":"2026-08-05T23:02:04.481412Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2406.11409","last_updated":"2024-06-19T02:37:50Z","snapshot_observed_at":"2026-08-16T21:13:11.293578Z","submitted_at":"2024-06-17T10:54:35Z","title":"CodeGemma: Open Code Models Based on Gemma","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2406.11409","snapshot_observed_at":"2026-08-05T23:02:03.431922Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":49,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.431922Z"},"links":{"cited_paper":"/paper/2406.11409","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:cbaaf7cbd0c5f16029a9b5c5780ea8c1b38c2d4665129130b9a196d26e63e207","observation_id":"c47e1fa5-70dc-440a-9b9c-3046dc862e51","resolution":{"observed_at":"2026-08-05T23:02:03.431922Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2004.13876","last_updated":"2020-10-12T08:05:13Z","snapshot_observed_at":"2026-07-06T09:16:02.654653Z","submitted_at":"2020-04-28T22:27:19Z","title":"The Explanation Game: Towards Prediction Explainability through Sparse Communication","version":2},"cited_work":{"arxiv_id":"2004.13876","doi":null,"metadata_source":"pith","pith_arxiv_id":"2004.13876","snapshot_observed_at":"2026-08-05T23:02:03.603594Z","title":"The Explanation Game: Towards Prediction Explainability through Sparse Communication","venue":"cs.CL","work_id":"ba1305ff-91fd-4a16-84ab-2f1b2c98dc25","year":2020},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":50,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.434827Z"},"links":{"cited_paper":"/paper/2004.13876","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b82018f5af78746ab5fa568c2f09429e6100101526c760c6e7248782600ed745","observation_id":"5bdfcb10-c292-48ff-9653-f5f9cff57e58","resolution":{"observed_at":"2026-08-05T23:02:03.608826Z","resolver_source":"local_arxiv","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2412.14399","last_updated":"2026-04-13T03:46:05Z","snapshot_observed_at":"2026-08-15T01:35:08.019638Z","submitted_at":"2024-12-18T23:14:59Z","title":"NESA: Relational Neuro-Symbolic Static Program Analysis","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2412.14399","snapshot_observed_at":"2026-08-05T23:02:03.437794Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":51,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.437794Z"},"links":{"cited_paper":"/paper/2412.14399","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:62f6df2c3fd9984b8134fb92aaf00e41dfc24fdb03da6a7856befae8b8c2e379","observation_id":"779100e0-6f5e-4d01-ae36-4b8033ddd7fb","resolution":{"observed_at":"2026-08-05T23:02:03.437794Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.470405Z","title":null,"venue":null,"work_id":"bfedd9ea-c18c-4a93-9eae-3826f67f0a03","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":52,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.440452Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:04731b60c9b138adac96716d55b55d0a266ffbe02c20f81b007a10ca2d3d150f","observation_id":"99ca6a44-0ac0-4e94-9216-598f47114bf2","resolution":{"observed_at":"2026-08-05T23:02:04.473272Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.462063Z","title":null,"venue":null,"work_id":"aabc981c-173b-4687-adad-b873b9a4d8a1","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":53,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.442828Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:acd7c57db60b095fd0b790516aa82a1b7a12fc47c60c95c273cb8eda50f1a32b","observation_id":"b6c1e233-af7e-44a6-b6b6-574856ded4c9","resolution":{"observed_at":"2026-08-05T23:02:04.464744Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.453495Z","title":null,"venue":null,"work_id":"7729df14-a561-4577-ae6e-5c1e8f10f413","year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":54,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.445290Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:e9ecb233755c47d07abbe06e45d22801d320eca15a7ed296847af986c015d40e","observation_id":"5a5a61a8-3682-463d-ab41-4670dd407730","resolution":{"observed_at":"2026-08-05T23:02:04.456268Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:03.450682Z","title":null,"venue":null,"work_id":null,"year":2022},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":55,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.450682Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b91baf9d12376f8d7c81f49ac7a8daf396f50f08bade65afcaee8d6cd644ac05","observation_id":"ad79cc4b-55ec-446e-ad08-4cd6457b2105","resolution":{"observed_at":"2026-08-05T23:02:03.450682Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2407.16741","last_updated":"2025-04-18T18:14:31Z","snapshot_observed_at":"2026-08-18T20:14:04.086811Z","submitted_at":"2024-07-23T17:50:43Z","title":"OpenHands: An Open Platform for AI Software Developers as Generalist Agents","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2407.16741","snapshot_observed_at":"2026-08-05T23:02:03.447966Z","title":"arXiv preprint arXiv:2407.16741 (2024)","venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":56,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.447966Z"},"links":{"cited_paper":"/paper/2407.16741","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b62168b4b09c54c10e2ea1bf0e9e064bb16cf61c16ca44b757f641d9e7b30dc2","observation_id":"0796d206-f6d2-495c-a0e7-46eeff10f9e8","resolution":{"observed_at":"2026-08-05T23:02:03.447966Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.433420Z","title":null,"venue":null,"work_id":"891e7b85-1018-46b3-9ca3-feeec912a238","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":57,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.459236Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:2e4695e6a7eb381f9c942be4a47430e8553bfa0bee68f23779c720454334b9fb","observation_id":"5f7e190d-9e60-41ac-ad5d-a2a2809e42ca","resolution":{"observed_at":"2026-08-05T23:02:04.436434Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:03.453549Z","title":null,"venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":58,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.453549Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:a5b2ab1c495ee3150d87f4027fd33b304e58a384a4af99a5388f006515f6b935","observation_id":"d563b519-e2b5-44dc-8bd3-558b676f271e","resolution":{"observed_at":"2026-08-05T23:02:03.453549Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.419837Z","title":null,"venue":null,"work_id":"ab55fe80-e5e7-4040-a215-3a29fb8946a0","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":59,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.467514Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:370acddad2051bbc26846ccb2dbe16f1351feb5be607031d977c9c4282bd52bc","observation_id":"252d4ab9-d22f-41e1-94eb-ea0596f26d27","resolution":{"observed_at":"2026-08-05T23:02:04.422321Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2411.12882","last_updated":"2025-06-06T05:27:10Z","snapshot_observed_at":"2026-08-15T15:30:04.308785Z","submitted_at":"2024-11-19T22:00:01Z","title":"ProSec: Fortifying Code LLMs with Proactive Security Alignment","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2411.12882","snapshot_observed_at":"2026-08-05T23:02:03.469932Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":60,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.469932Z"},"links":{"cited_paper":"/paper/2411.12882","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:50d76623a60a4e0aa7b8190887580dc133010082a5abc5b7deb7df008cd883a0","observation_id":"ee370d12-86b4-466a-a9b3-19ff3c820a9f","resolution":{"observed_at":"2026-08-05T23:02:03.469932Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:03.461992Z","title":null,"venue":null,"work_id":null,"year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":61,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.461992Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:fe0755da3cc52b846621670945ca75babe4cb842e6e79a0180b796faaceea3f8","observation_id":"242d78fb-30c9-4d12-a32d-c99d8e16e539","resolution":{"observed_at":"2026-08-05T23:02:03.461992Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2407.01489","last_updated":"2024-10-29T17:29:27Z","snapshot_observed_at":"2026-08-17T17:32:59.508600Z","submitted_at":"2024-07-01T17:24:45Z","title":"Agentless: Demystifying LLM-based Software Engineering Agents","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2407.01489","snapshot_observed_at":"2026-08-05T23:02:03.464619Z","title":"arXiv preprint arXiv:2407.01489 (2024)","venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":62,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.464619Z"},"links":{"cited_paper":"/paper/2407.01489","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:70776f6a7ea2c97f5dd0fb3d64f146df72eca6f82a419bf6f920ae30ee72b9b1","observation_id":"4a890799-cdbc-41ac-bd47-4518c0bc03ce","resolution":{"observed_at":"2026-08-05T23:02:03.464619Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"2505.13360","last_updated":"2026-04-24T18:23:38Z","snapshot_observed_at":"2026-08-14T13:31:11.360543Z","submitted_at":"2025-05-19T17:03:42Z","title":"What Prompts Don't Say: Understanding and Managing Underspecification in LLM Prompts","version":3},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2505.13360","snapshot_observed_at":"2026-08-05T23:02:03.480828Z","title":null,"venue":null,"work_id":null,"year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":63,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.480828Z"},"links":{"cited_paper":"/paper/2505.13360","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:e4e3c52957e6f0bb9ec83a86ed855144af31d25adffb68cf3c1868bbe2cec5c3","observation_id":"37f84041-7f3e-4595-97b0-8528b43515d7","resolution":{"observed_at":"2026-08-05T23:02:03.480828Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:03.483516Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":64,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.483516Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:e7ca37fcb2b7778d22a3e9244330f178297c85c8f82558155709cd41dcba60d6","observation_id":"9cdb16a8-c457-45ed-ba7e-e532312ce6ac","resolution":{"observed_at":"2026-08-05T23:02:03.483516Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.411329Z","title":null,"venue":null,"work_id":"7c9ac12d-9b98-4352-ae36-cd91e5c741df","year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":65,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.472981Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:c1c77bf420b4144a523c9c9195a9eddec2c7f239832026b082f07ef1672286e0","observation_id":"9f71f9dd-cb8b-4c3f-a888-f979984a6a22","resolution":{"observed_at":"2026-08-05T23:02:04.414093Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2410.01488","last_updated":"2024-10-02T12:36:53Z","snapshot_observed_at":"2026-08-16T13:13:23.445050Z","submitted_at":"2024-10-02T12:36:53Z","title":"SecCoder: Towards Generalizable and Robust Secure Code Generation","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2410.01488","snapshot_observed_at":"2026-08-05T23:02:03.488702Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":66,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.488702Z"},"links":{"cited_paper":"/paper/2410.01488","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:5029f68f91d8249363d6757a0d78eb64450521ea12dbf12106b0603d85fef7a1","observation_id":"5136dcc0-3b19-411f-a404-e32ddadd7820","resolution":{"observed_at":"2026-08-05T23:02:03.488702Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.394770Z","title":null,"venue":null,"work_id":"2dc61e17-7fd6-4474-b48f-0e892f25115a","year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":67,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.478454Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:6493bab725d258540ac6fdff80799de3b8c646ae0ae6b12e801d96eb8b13ee37","observation_id":"10eafa92-801b-4d56-a978-d97f7a2736e7","resolution":{"observed_at":"2026-08-05T23:02:04.397498Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.361722Z","title":null,"venue":null,"work_id":"925a90ad-8662-4a3c-89e9-63e5ae903486","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":68,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.494089Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:ddc4a2cb7cfc24e4249899d6bb030ab6a599ac6c6da3dfa88d74ed5fa8ea0759","observation_id":"b4c4db90-aed1-4568-bb27-db44d97a5d15","resolution":{"observed_at":"2026-08-05T23:02:04.364514Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.351562Z","title":null,"venue":null,"work_id":"93ba1a57-ec41-4f9f-bee9-2584239f8c5f","year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":69,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.496866Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:08777d5c08b9c02bafaaa0b3fcdef9d3aaf5d39c5fe8a420a87d9a43f54fa4b8","observation_id":"854c09b9-db02-45a4-9b99-fd270575fa90","resolution":{"observed_at":"2026-08-05T23:02:04.354829Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.380181Z","title":null,"venue":null,"work_id":"23d8e982-4a28-45bc-880a-b889f69a30f9","year":2020},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":70,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.486183Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:0d7b19fa9d0ea540e99fe4b12aef6e571df4e0be5f11459a0c58c9df2b388c69","observation_id":"0a64a76d-ffb1-43f4-92c2-f9a02f88a8a4","resolution":{"observed_at":"2026-08-05T23:02:04.383137Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.334337Z","title":null,"venue":null,"work_id":"af8cf461-2328-44e2-ac54-b50597ace4f8","year":2013},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":71,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.502681Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:43f04899390ea315e69396df65071b33f459395fbf181d0521d2ef3cb5b78797","observation_id":"1104cea2-1acd-4f5c-bb7e-3f5445834c46","resolution":{"observed_at":"2026-08-05T23:02:04.337080Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.371374Z","title":null,"venue":null,"work_id":"088725db-4341-4ecc-899d-a343767b3d5d","year":2017},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":72,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.491397Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:b07c3f735f518390b5050dc907eb800aac8a88763ed59507bf525ce5612e1479","observation_id":"69244edf-d914-48c9-8a1a-1a1473c22b07","resolution":{"observed_at":"2026-08-05T23:02:04.374320Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2410.12405","last_updated":"2024-10-16T09:38:13Z","snapshot_observed_at":"2026-08-20T00:22:48.174101Z","submitted_at":"2024-10-16T09:38:13Z","title":"ProSA: Assessing and Understanding the Prompt Sensitivity of LLMs","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2410.12405","snapshot_observed_at":"2026-08-05T23:02:03.507900Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":73,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.507900Z"},"links":{"cited_paper":"/paper/2410.12405","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:97a4437dc3223d720c613f28dc1163b35b1c3a81ee59a27d7c9d2849066d7d45","observation_id":"41e3edb8-238a-4631-af99-8b8d33935d24","resolution":{"observed_at":"2026-08-05T23:02:03.507900Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.342947Z","title":null,"venue":null,"work_id":"d62b5c2d-793c-49c0-8c3d-0e0bb3f95dc5","year":2025},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":75,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.500070Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:5f6eea3a68424f0966afc6a0c797b154af8260424eae54465e442e9b17f4625a","observation_id":"9728dfca-5142-406d-a6f7-3da57cf1f5d3","resolution":{"observed_at":"2026-08-05T23:02:04.346023Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.325647Z","title":null,"venue":null,"work_id":"1ecf7e86-fdd6-4022-9317-410196f3bcbd","year":2017},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":77,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.505252Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:f97c0f18483bca6f5905bc9dfb94cbfb3507b0947beff2dd9a29d677f20b1059","observation_id":"9af01e75-e1e1-45f5-b7bd-1eceb230366f","resolution":{"observed_at":"2026-08-05T23:02:04.328319Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.402862Z","title":"In International Conference on Computer Aided Verification","venue":null,"work_id":"7918451f-7c44-4ac3-b63a-b81c12ab48d3","year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":2021,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.475935Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:ef3fc820570806acedce169aa7a0a4ac508ca617c4402cb05ac7acc2a893cd05","observation_id":"935a088a-4241-49cb-b372-9b03af3e2619","resolution":{"observed_at":"2026-08-05T23:02:04.405774Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":{"arxiv_id":"2312.02120","last_updated":"2024-06-07T02:50:56Z","snapshot_observed_at":"2026-08-16T22:22:41.448725Z","submitted_at":"2023-12-04T18:50:35Z","title":"Magicoder: Empowering Code Generation with OSS-Instruct","version":2},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"2312.02120","snapshot_observed_at":"2026-08-05T23:02:03.456536Z","title":"arXiv preprint arXiv:2312.02120 (2023)","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":2023,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:03.456536Z"},"links":{"cited_paper":"/paper/2312.02120","citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:d068fcb667b499514ad4820f781cd74d3217a78ab0d260dd62cb1d577afd0322","observation_id":"f0e5e6e4-7f7c-4651-a4f7-9da486276f81","resolution":{"observed_at":"2026-08-05T23:02:03.456536Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-05T23:02:04.652225Z","title":"In Pro- ceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering","venue":null,"work_id":"6894fb11-e76c-42b2-b572-026ed7a0be05","year":null},"citing_paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications","version":1},"reference_index":2024,"source":"pdf_text","source_observed_at":"2026-08-05T23:02:00.381497Z"},"links":{"citing_paper":"/paper/2508.06017"},"observation_digest":"sha256:3290a72e992166cc3d71f40cccb3e7ca28c7444675126ff110fc7e117c2416c2","observation_id":"e542cc9d-875b-4be9-8444-50e301c9d007","resolution":{"observed_at":"2026-08-05T23:02:04.655991Z","resolver_source":"raw_fallback","status":"verified_fuzzy"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-21T06:32:19.484+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"state":"measured"}}],"paper":{"arxiv_id":"2508.06017","last_updated":"2025-08-08T05:04:47Z","latest_version":1,"primary_category":"cs.SE","snapshot_observed_at":"2026-08-18T13:06:11.606402Z","submitted_at":"2025-08-08T05:04:47Z","title":"Position: Intelligent Coding Systems Should Write Programs with Justifications"},"reference_resolution":{"displayed":78,"state_counts":{"malformed_identifier":0,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":69,"verified_exact":6,"verified_fuzzy":3},"total_outbound_references":78},"refusal":"A citation records a reference. It does not transfer a finding from one paper to another.","schema":"pith.paper-citation-record.v1","standing_sources":[{"observed_at":"2026-08-21T06:32:19.484+00:00","source":"crossref"},{"observed_at":"2026-08-21T06:32:16.066871+00:00","source":"retraction_watch"}],"thesis":"As of 21 August 2026, this Paper Citation Record lists 78 of 78 outbound references and 0 inbound Pith citation observations for arXiv:2508.06017."}